home *** CD-ROM | disk | FTP | other *** search
/ Aminet 4 / Aminet 4 - November 1994.iso / aminet / dev / gcc / gcc260diffs.lha / gnu / src-patches / binutils-1.8.x.diffs next >
Encoding:
Text File  |  1994-07-30  |  87.6 KB  |  3,371 lines
  1. diff -2rcN binutils-1.8.x/Makefile binutils-1.8.x-amiga/Makefile
  2. *** binutils-1.8.x/Makefile    Wed Nov 27 22:48:58 1991
  3. --- binutils-1.8.x-amiga/Makefile    Mon Jul 18 23:46:58 1994
  4. ***************
  5. *** 20,26 ****
  6.   
  7.   
  8. ! GNUCC = gcc -O
  9. ! #CC = gcc -O
  10. ! bindir=/usr/local/bin
  11.   
  12.   # for BSD systems
  13. --- 20,36 ----
  14.   
  15.   
  16. ! GNUCC = gcc 
  17. ! bindir=/gnu/bin
  18. ! 
  19. ! # for AmigaDOS systems
  20. ! CFLAGS = -O2
  21. ! LDFLAGS = -s
  22. ! # for AmigaDOS Cross-Compiler
  23. ! # CFLAGS = -O2 -DMCH_AMIGA -DCROSS_LINKER
  24. ! # Don't include gprof.
  25. ! PROGS = $(archpfx)ld $(archpfx)size \
  26. !         $(archpfx)nm $(archpfx)strip $(archpfx)ar $(archpfx)ranlib
  27. ! CC = gcc
  28. ! bindir=/gnu/bin
  29.   
  30.   # for BSD systems
  31. ***************
  32. *** 30,35 ****
  33.   # on most systems (trouble with N_DATADDR).  I've fixed some of
  34.   # those problems, though.
  35. ! PROGS = $(archpfx)gprof $(archpfx)ld $(archpfx)size \
  36. !         $(archpfx)nm $(archpfx)strip $(archpfx)ar $(archpfx)ranlib
  37.   
  38.   # for USG systems using COFF_ENCAPSULATE
  39. --- 40,45 ----
  40.   # on most systems (trouble with N_DATADDR).  I've fixed some of
  41.   # those problems, though.
  42. ! #PROGS = $(archpfx)gprof $(archpfx)ld $(archpfx)size \
  43. ! #        $(archpfx)nm $(archpfx)strip $(archpfx)ar $(archpfx)ranlib
  44.   
  45.   # for USG systems using COFF_ENCAPSULATE
  46. ***************
  47. *** 37,43 ****
  48.   # Note that you should leave a copy of `ar' in this directory
  49.   # after you install it, since `ranlib' will try to run it from here.
  50. ! CFLAGS = -DWYSE -DUSG -DCOFF_ENCAPSULATE -DPORTAR -DNON_NATIVE -DPIGNAL_MISSING
  51. ! PROGS = ld size nm strip ar robotussin objdump ranlib gprof
  52. ! SIGNAME = signame.o
  53.   # On ALTOS systems, add -DALTOS to CFLAGS.
  54.   
  55. --- 47,53 ----
  56.   # Note that you should leave a copy of `ar' in this directory
  57.   # after you install it, since `ranlib' will try to run it from here.
  58. ! #CFLAGS = -g -DUSG -DCOFF_ENCAPSULATE -DPORTAR -DNON_NATIVE -DPIGNAL_MISSING
  59. ! #PROGS = ld size nm strip ar robotussin objdump ranlib gprof
  60. ! #SIGNAME = signame.o
  61.   # On ALTOS systems, add -DALTOS to CFLAGS.
  62.   
  63. ***************
  64. *** 45,49 ****
  65.   #incompatiable functions from -lPW (like index()), but if you
  66.   #want to be lazy, uncomment this line
  67. ! ALLOCALIBS = -lPW
  68.   
  69.   # For HP-UX systems
  70. --- 55,59 ----
  71.   #incompatiable functions from -lPW (like index()), but if you
  72.   #want to be lazy, uncomment this line
  73. ! #ALLOCALIBS = -lPW
  74.   
  75.   # For HP-UX systems
  76. ***************
  77. *** 84,88 ****
  78.   CPLUS_DEM = $(archpfx)cplus-dem.o
  79.   
  80. ! LIBS=$(MALLOC) $(ALLOCALIBS) $(SIGNAME)
  81.   
  82.   all: $(PROGS)
  83. --- 94,98 ----
  84.   CPLUS_DEM = $(archpfx)cplus-dem.o
  85.   
  86. ! LIBS=$(ALLOCALIBS) $(SIGNAME)
  87.   
  88.   all: $(PROGS)
  89. ***************
  90. *** 91,111 ****
  91.   # LIBS is used here since ld needs to use alloca.
  92.   # Alternatively, compile it with GNU C--then the compiler handles alloca.
  93. !     $(CC) $(CFLAGS) -o $(archpfx)ld $(archpfx)ld.o $(GNU_GETOPT_LONG) $(CPLUS_DEM) $(LIBS)
  94.   
  95.   $(archpfx)size: $(archpfx)size.o
  96. !     $(CC) $(CFLAGS) -o $(archpfx)size $(archpfx)size.o
  97.   
  98.   $(archpfx)nm: $(archpfx)nm.o $(GNU_GETOPT_LONG) $(CPLUS_DEM) $(MALLOC)
  99. !     $(CC) $(CFLAGS) -o $(archpfx)nm $(archpfx)nm.o \
  100.           $(GNU_GETOPT_LONG) $(CPLUS_DEM) $(LIBS) $(MALLOC)
  101.   
  102.   $(archpfx)strip: $(archpfx)strip.o $(GNU_GETOPT_LONG)
  103. !     $(CC) $(CFLAGS) -o $(archpfx)strip $(archpfx)strip.o $(GNU_GETOPT_LONG) $(LIBS)
  104.   
  105.   $(archpfx)ar: $(archpfx)ar.o
  106. !     $(CC) $(CFLAGS) -o $(archpfx)ar $(archpfx)ar.o $(LIBS)
  107.   
  108.   $(archpfx)gprof: $(archpfx)gprof.o $(GNU_GETOPT_LONG) $(CPLUS_DEM)
  109. !     $(GNUCC) $(CFLAGS) -o $(archpfx)gprof $(archpfx)gprof.o \
  110.           $(GNU_GETOPT_LONG) $(CPLUS_DEM) $(LIBS)
  111.   $(archpfx)gprof.o: gprof.c gmon.h 
  112. --- 101,121 ----
  113.   # LIBS is used here since ld needs to use alloca.
  114.   # Alternatively, compile it with GNU C--then the compiler handles alloca.
  115. !     $(CC) $(LDFLAGS) -o $(archpfx)ld $(archpfx)ld.o $(GNU_GETOPT_LONG) $(CPLUS_DEM) $(LIBS)
  116.   
  117.   $(archpfx)size: $(archpfx)size.o
  118. !     $(CC) $(LDFLAGS) -o $(archpfx)size $(archpfx)size.o
  119.   
  120.   $(archpfx)nm: $(archpfx)nm.o $(GNU_GETOPT_LONG) $(CPLUS_DEM) $(MALLOC)
  121. !     $(CC) $(LDFLAGS) -o $(archpfx)nm $(archpfx)nm.o \
  122.           $(GNU_GETOPT_LONG) $(CPLUS_DEM) $(LIBS) $(MALLOC)
  123.   
  124.   $(archpfx)strip: $(archpfx)strip.o $(GNU_GETOPT_LONG)
  125. !     $(CC) $(LDFLAGS) -o $(archpfx)strip $(archpfx)strip.o $(GNU_GETOPT_LONG) $(LIBS)
  126.   
  127.   $(archpfx)ar: $(archpfx)ar.o
  128. !     $(CC) $(LDFLAGS) -o $(archpfx)ar $(archpfx)ar.o $(LIBS)
  129.   
  130.   $(archpfx)gprof: $(archpfx)gprof.o $(GNU_GETOPT_LONG) $(CPLUS_DEM)
  131. !     $(GNUCC) $(LDFLAGS) -o $(archpfx)gprof $(archpfx)gprof.o \
  132.           $(GNU_GETOPT_LONG) $(CPLUS_DEM) $(LIBS)
  133.   $(archpfx)gprof.o: gprof.c gmon.h 
  134. ***************
  135. *** 113,127 ****
  136.   
  137.   $(archpfx)ranlib: $(archpfx)ranlib.o $(GNU_GETOPT_LONG)
  138. !     $(CC) $(CFLAGS) -o $(archpfx)ranlib $(archpfx)ranlib.o $(GNU_GETOPT_LONG) $(LIBS)
  139.   $(archpfx)ranlib.o: ranlib.c
  140. !     $(CC) -c $(CFLAGS) -DAR_PROG=\"/usr/local/gnu/binutils/ar\" ranlib.c $(OUTPUT_OPTION)
  141.   
  142.   $(archpfx)objdump: $(archpfx)objdump.o $(GNU_GETOPT_LONG) a.out.gnu.h
  143. !     $(CC) $(CFLAGS) -o $(archpfx)objdump $(archpfx)objdump.o \
  144.           $(GNU_GETOPT_LONG) $(LIBS)
  145.   
  146.   # Robotussin is NOT part of `all'.
  147.   $(archpfx)robotussin: $(archpfx)robotussin.o
  148. !     $(CC) $(CFLAGS) -o $(archpfx)robotussin $(archpfx)robotussin.o
  149.   
  150.   libc.a: $(archpfx)robotussin libconvert $(archpfx)ar
  151. --- 123,137 ----
  152.   
  153.   $(archpfx)ranlib: $(archpfx)ranlib.o $(GNU_GETOPT_LONG)
  154. !     $(CC) $(LDFLAGS) -o $(archpfx)ranlib $(archpfx)ranlib.o $(GNU_GETOPT_LONG) $(LIBS)
  155.   $(archpfx)ranlib.o: ranlib.c
  156. !     $(CC) -c $(CFLAGS) -DAR_PROG=\"$(bindir)/ar\" ranlib.c $(OUTPUT_OPTION)
  157.   
  158.   $(archpfx)objdump: $(archpfx)objdump.o $(GNU_GETOPT_LONG) a.out.gnu.h
  159. !     $(CC) $(LDFLAGS) -o $(archpfx)objdump $(archpfx)objdump.o \
  160.           $(GNU_GETOPT_LONG) $(LIBS)
  161.   
  162.   # Robotussin is NOT part of `all'.
  163.   $(archpfx)robotussin: $(archpfx)robotussin.o
  164. !     $(CC) $(LDFLAGS) -o $(archpfx)robotussin $(archpfx)robotussin.o
  165.   
  166.   libc.a: $(archpfx)robotussin libconvert $(archpfx)ar
  167. ***************
  168. *** 146,150 ****
  169.   install: $(PROGS)
  170.       for file in $(PROGS); do \
  171. !     cp $$file $(bindir)/$${file}.new; \
  172. !     mv $(bindir)/$${file}.new $(bindir)/$$file; \
  173.       done
  174. --- 156,161 ----
  175.   install: $(PROGS)
  176.       for file in $(PROGS); do \
  177. !     cp $${file} $(bindir)/$${file}.new; \
  178. !     mv $(bindir)/$${file} $(bindir)/$${file}.bak; \
  179. !     mv $(bindir)/$${file}.new $(bindir)/$${file}; \
  180.       done
  181. diff -2rcN binutils-1.8.x/ar.c binutils-1.8.x-amiga/ar.c
  182. *** binutils-1.8.x/ar.c    Wed Jun 13 05:47:50 1990
  183. --- binutils-1.8.x-amiga/ar.c    Wed Sep 22 12:45:59 1993
  184. ***************
  185. *** 993,996 ****
  186. --- 993,997 ----
  187.     close (outdesc);
  188.   
  189. + #ifndef amigados
  190.     if (!appendflag)
  191.       if (rename (tempname, archive))
  192. ***************
  193. *** 998,1001 ****
  194. --- 999,1011 ----
  195.   
  196.     close_archive ();
  197. + #else
  198. +   /* we *have* to close the file before we rename it, because otherwise
  199. +    * AmigaDOS will just abort with OBJECT_IN_USE_ERROR */
  200. +   close_archive ();
  201. + 
  202. +   if (!appendflag)
  203. +     if (rename (tempname, archive))
  204. +       pfatal_with_name (tempname);
  205. + #endif
  206.   }
  207.   
  208. ***************
  209. *** 1957,1961 ****
  210. --- 1967,1973 ----
  211.        unsigned int size;
  212.   {
  213. + #ifndef __STDC__
  214.     extern char *malloc ();
  215. + #endif
  216.     char *result = malloc (size);
  217.     if (result == 0)
  218. ***************
  219. *** 1969,1973 ****
  220. --- 1981,1987 ----
  221.        unsigned int size;
  222.   {
  223. + #ifndef __STDC__
  224.     extern char *realloc ();
  225. + #endif
  226.     char *result = realloc (ptr, size);
  227.     if (result == 0)
  228. diff -2rcN binutils-1.8.x/cplus-dem.c binutils-1.8.x-amiga/cplus-dem.c
  229. *** binutils-1.8.x/cplus-dem.c    Wed Jun 13 05:42:34 1990
  230. --- binutils-1.8.x-amiga/cplus-dem.c    Wed Sep 22 12:45:32 1993
  231. ***************
  232. *** 49,53 ****
  233.   
  234.   #if !defined(sequent) && !defined(NeXT)
  235. ! #include <memory.h>
  236.   #else
  237.   #define memcpy(s1, s2, n) strncpy(s1, s2, n) 
  238. --- 49,53 ----
  239.   
  240.   #if !defined(sequent) && !defined(NeXT)
  241. ! /* #include <memory.h> */
  242.   #else
  243.   #define memcpy(s1, s2, n) strncpy(s1, s2, n) 
  244. diff -2rcN binutils-1.8.x/ld.c binutils-1.8.x-amiga/ld.c
  245. *** binutils-1.8.x/ld.c    Sat Jun 18 00:10:10 1994
  246. --- binutils-1.8.x-amiga/ld.c    Sat Jul 30 13:26:33 1994
  247. ***************
  248. *** 17,23 ****
  249.   
  250.   /* Written by Richard Stallman with some help from Eric Albert.
  251. !    Set, indirect, and warning symbol features added by Randy Smith.  */
  252.   
  253.   #include <ar.h>
  254.   #include <stdio.h>
  255.   #include <sys/types.h>
  256. --- 17,38 ----
  257.   
  258.   /* Written by Richard Stallman with some help from Eric Albert.
  259. !    Set, indirect, and warning symbol features added by Randy Smith.
  260. !    Support for generation of Amiga load files added by Markus Wild.
  261. !    Flavor extension by Fred Fish
  262. !    Modified for AmigaDOS cross-linker by Philippe Brand
  263. !    Bug fixes by Matthias Fleischer
  264. !    Additional work by Gunther Nikl */
  265.   
  266. + #ifdef amigados
  267. + #ifndef STANDARD_SEARCH_DIRS
  268. + #define STANDARD_SEARCH_DIRS "gnu:lib","gnu:os-lib"
  269. + #endif
  270. + #endif
  271. + 
  272. + #if defined(amigados) && defined(CROSS_LINKER)
  273. + #include </usr/local/amigados/include/ar.h>
  274. + #else
  275.   #include <ar.h>
  276. + #endif
  277.   #include <stdio.h>
  278.   #include <sys/types.h>
  279. ***************
  280. *** 31,34 ****
  281. --- 46,51 ----
  282.   #include <fcntl.h>
  283.   #endif
  284. + /* JPB, 7 Jun 1992: MAXNAMLEN required for long name hack. */
  285. + #include <dirent.h>
  286.   
  287.   #if !defined(A_OUT) && !defined(MACH_O)
  288. ***************
  289. *** 40,46 ****
  290. --- 57,98 ----
  291.   #include "a.out.encap.h"
  292.   #else
  293. + #if defined(amigados) && defined(CROSS_LINKER)
  294. + # include </usr/local/amigados/include/a.out.h>
  295. + #else
  296.   #include <a.out.h>
  297.   #endif
  298.   #endif
  299. + #endif
  300. + 
  301. + #ifdef MCH_AMIGA
  302. + #define HUNK_INSTEAD_OF_A_OUT
  303. + int number_of_code_hunk,
  304. +     code_mem_type,
  305. +     number_of_data_hunk,
  306. +     data_mem_type,
  307. +     number_of_bss_hunk,
  308. +     bss_mem_type,
  309. +     number_of_debug_hunk,
  310. +     current_hunk = 0,
  311. +     offset_of_debug_hunk,
  312. +     amiga_symbols_only,
  313. +     long_data_hunk = 1,
  314. +     databss_together = 0,
  315. +     numdatadata_relocs = 0,
  316. +     output_datadata_relocs = 0,
  317. +     datadata_relocs_offset = 0;
  318. + #define LONGSIZE(l) ((((l) + 3) & ~3) >> 2)
  319. + /* this is the private format of the debug-hunk: */
  320. +    struct debug_hunk {
  321. +      unsigned long  id;  /* Filesystem-imposed: HUNK_DEBUG (0x3f1) */
  322. +      unsigned long  len; /* "" : length in longs -> LONGSIZE(real_lenght) */
  323. +      /* the following part is somehow a truncated exec-struct: */
  324. +      unsigned long  magic; /* should be ZMAGIC (just for fun:-)), to be recognised
  325. +                 * by the other tools as this special frame */
  326. +      unsigned long  syms;  /* size of symbol-table */
  327. +      unsigned long  strs;  /* size of string table */
  328. +      /* here follows the actual data */
  329. +    } dh;
  330. + #endif
  331.   
  332.   #ifdef MACH_O
  333. ***************
  334. *** 105,109 ****
  335.   
  336.   char *progname;
  337. ! 
  338.   /* System dependencies */
  339.   
  340. --- 157,161 ----
  341.   
  342.   char *progname;
  343. ! 
  344.   /* System dependencies */
  345.   
  346. ***************
  347. *** 191,194 ****
  348. --- 243,262 ----
  349.   #endif /* Sun.  */
  350.   
  351. + #ifdef amigados
  352. + /* same trick as with sun[23] */
  353. + /* Set the machine type according to the machine type of the .o files.
  354. +    If they are all sun2 (68010), then the type of the executable is sun2.
  355. +    If any is sun3 (68020), then the type of the executable is sun3.
  356. +    This is consistent with the Sun loader and more useful than having
  357. +    it depend on which machine you are on when you run ld.  */
  358. + static int amiga_machtype = MID_SUN010;
  359. + #define INITIALIZE_HEADER outheader.a_machtype = amiga_machtype
  360. + #define READ_HEADER_HOOK(machtype) \
  361. +   if (machtype == MID_SUN020)        \
  362. +     {                     \
  363. +       amiga_machtype = MID_SUN020;   \
  364. +     }
  365. + #endif
  366. + 
  367.   #ifdef ALTOS
  368.   #define INITIALIZE_HEADER N_SET_MACHTYPE (outheader, M_68020)
  369. ***************
  370. *** 230,233 ****
  371. --- 298,305 ----
  372.   #define SEEK_CUR 1
  373.   #endif
  374. + /* Phil.B: 1-Apr-94: same trick for SEEK_END */
  375. + #ifndef SEEK_END
  376. + #define SEEK_END L_XTND
  377. + #endif
  378.   
  379.   /*
  380. ***************
  381. *** 369,372 ****
  382. --- 441,445 ----
  383.   #undef RELOC_ADD_EXTRA
  384.   #define RELOC_PCREL_P(r)        ((r)->r_pcrel)
  385. + #define RELOC_BASEREL_P(r)        ((r)->r_baserel)
  386.   #define RELOC_VALUE_RIGHTSHIFT(r)    0
  387.   #define RELOC_TARGET_SIZE(r)        ((r)->r_length)
  388. ***************
  389. *** 385,389 ****
  390.   #endif
  391.   
  392. ! 
  393.   /* Special global symbol types understood by GNU LD.  */
  394.   
  395. --- 458,462 ----
  396.   #endif
  397.   
  398. ! 
  399.   /* Special global symbol types understood by GNU LD.  */
  400.   
  401. ***************
  402. *** 532,536 ****
  403.   
  404.   #endif /* not __GNU_STAB__ */
  405. ! 
  406.   /* Symbol table */
  407.   
  408. --- 605,609 ----
  409.   
  410.   #endif /* not __GNU_STAB__ */
  411. ! 
  412.   /* Symbol table */
  413.   
  414. ***************
  415. *** 685,689 ****
  416.   symbol *etext_symbol_alt;
  417.   symbol *end_symbol_alt;
  418. ! 
  419.   /* Kinds of files potentially understood by the linker. */
  420.   
  421. --- 758,770 ----
  422.   symbol *etext_symbol_alt;
  423.   symbol *end_symbol_alt;
  424. ! 
  425. ! #ifdef amigados
  426. ! symbol *sdata_symbol;    /* the symbol __sdata */
  427. ! symbol *text_size_symbol;
  428. ! symbol *data_size_symbol;
  429. ! symbol *bss_size_symbol;
  430. ! symbol *datadata_reloc_symbol = 0;
  431. ! #endif
  432. ! 
  433.   /* Kinds of files potentially understood by the linker. */
  434.   
  435. ***************
  436. *** 821,825 ****
  437.   /* Length of that vector.  */
  438.   int number_of_files;
  439. ! 
  440.   /* When loading the text and data, we can avoid doing a close
  441.      and another open between members of the same library.
  442. --- 902,906 ----
  443.   /* Length of that vector.  */
  444.   int number_of_files;
  445. ! 
  446.   /* When loading the text and data, we can avoid doing a close
  447.      and another open between members of the same library.
  448. ***************
  449. *** 868,874 ****
  450. --- 949,960 ----
  451.   #endif
  452.   
  453. + #if 0
  454.   /* Descriptor for writing that file with `mywrite'.  */
  455.   
  456.   int outdesc;
  457. + #endif
  458. + 
  459. + /* use outstream instead of outdesc thru the whole file, it's MUCH faster.. */
  460. + FILE *outstream = (FILE *) 0;
  461.   
  462.   /* The following are computed by `digest_symbols'.  */
  463. ***************
  464. *** 910,913 ****
  465. --- 996,1003 ----
  466.      written. */
  467.   unsigned long *set_vectors;
  468. + #ifdef HUNK_INSTEAD_OF_A_OUT
  469. + /* which vector entry has to be relocated? */
  470. + unsigned char *rel_vectors;
  471. + #endif
  472.   
  473.   /* Amount of cleared space to leave at the end of the text segment.  */
  474. ***************
  475. *** 930,934 ****
  476.     int library_member_offset;
  477.   };
  478. ! 
  479.   /* Record most of the command options.  */
  480.   
  481. --- 1020,1024 ----
  482.     int library_member_offset;
  483.   };
  484. ! 
  485.   /* Record most of the command options.  */
  486.   
  487. ***************
  488. *** 994,997 ****
  489. --- 1084,1091 ----
  490.   int n_search_dirs;
  491.   
  492. + /* Vector of flavors to search for. */
  493. + char **flavors;
  494. + int n_flavors;
  495. + 
  496.   /* Non zero means to create the output executable.
  497.      Cleared by nonfatal errors.  */
  498. ***************
  499. *** 1008,1017 ****
  500. --- 1102,1117 ----
  501.   int cl_refs_allocated;
  502.   
  503. + /* JPB, 7 Jun 1992: Global variable needed for long name hack. */
  504. + static int ar_hdr_size;
  505. + 
  506.   #ifndef bcopy
  507.   void bcopy (), bzero ();
  508.   #endif
  509. + #ifndef __STDC__
  510.   char *malloc (), *realloc ();
  511.   void free ();
  512. + #endif
  513.   
  514. + char *getenv ();
  515.   char *xmalloc ();
  516.   char *xrealloc ();
  517. ***************
  518. *** 1035,1038 ****
  519. --- 1135,1153 ----
  520.   void write_header ();
  521.   void write_text ();
  522. + #ifdef HUNK_INSTEAD_OF_A_OUT
  523. + void write_datadata_relocs ();
  524. + void write_hunk_header ();
  525. + void conditionally_rewrite_headers ();
  526. + void write_bss ();
  527. + void init_reloc_hunk ();
  528. + void add_to_reloc_hunk ();
  529. + void write_reloc_hunk ();
  530. + void init_symbol_hunks ();
  531. + void add_to_symbol_hunk ();
  532. + void write_symbol_hunk ();
  533. + void look_for_symbols ();
  534. + void look_for_file_symbols ();
  535. + void relocate_set_vectors ();
  536. + #endif
  537.   void read_file_relocation ();
  538.   void write_data ();
  539. ***************
  540. *** 1046,1050 ****
  541.   char *get_file_name ();
  542.   symbol *getsym (), *getsym_soft ();
  543. ! 
  544.   int
  545.   main (argc, argv)
  546. --- 1161,1166 ----
  547.   char *get_file_name ();
  548.   symbol *getsym (), *getsym_soft ();
  549. ! int compare_longs (), compare_strings ();
  550. ! 
  551.   int
  552.   main (argc, argv)
  553. ***************
  554. *** 1052,1059 ****
  555.        int argc;
  556.   {
  557.     page_size = getpagesize ();
  558.     progname = argv[0];
  559.   
  560. ! #ifdef RLIMIT_STACK
  561.     /* Avoid dumping core on large .o files.  */
  562.     {
  563. --- 1168,1186 ----
  564.        int argc;
  565.   {
  566. + /* Phil.B 09-Jul-94: use 4KB as page size in order to be compatible with Gigamem
  567. +    although getpagesize() is present in ixemul.library, we want to compile
  568. +    without it */
  569. + #ifdef amigados
  570. +   page_size = 4096;
  571. + #else
  572.     page_size = getpagesize ();
  573. + #endif
  574.     progname = argv[0];
  575.   
  576. ! /* Phil.B 09-Jul-94: amigados doesn't have stack growing so this is not
  577. !    necessary and more than that disable ld to be compiled using libnix
  578. !    BTW as for now those functions returns 0 in  ixemul.library.
  579. !    That's emulation! ;-) */
  580. ! #if defined(RLIMIT_STACK) && !defined(amigados)
  581.     /* Avoid dumping core on large .o files.  */
  582.     {
  583. ***************
  584. *** 1091,1094 ****
  585. --- 1218,1224 ----
  586.     force_executable = 0;
  587.     set_element_prefixes = 0;
  588. + #ifdef HUNK_INSTEAD_OF_A_OUT
  589. +   amiga_symbols_only = 1;
  590. + #endif
  591.   
  592.     /* Initialize the cumulative counts of symbols.  */
  593. ***************
  594. *** 1149,1157 ****
  595.     exit (!make_executable);
  596.   }
  597. ! 
  598.   void add_cmdline_ref ();
  599.   
  600.   static struct option longopts[] =
  601.   {
  602.     {"d", 0, 0, 'd'},
  603.     {"dc", 0, 0, 'd'},        /* For Sun compatibility. */
  604. --- 1279,1317 ----
  605.     exit (!make_executable);
  606.   }
  607. ! 
  608. ! #ifdef amigados
  609. ! /* support hunk loading to a chip or fast memory */
  610. ! void set_mem_type(char *argstr, int memtype)
  611. ! {
  612. !    static char memstr[]="cdb";
  613. ! 
  614. !    if (!argstr)
  615. !      argstr=memstr;
  616. ! 
  617. !    if (strchr(argstr,'c')||strchr(argstr,'t'))
  618. !      code_mem_type=memtype;
  619. ! 
  620. !    if (strchr(argstr,'d'))
  621. !      data_mem_type=memtype;
  622. ! 
  623. !    if (strchr(argstr,'b'))
  624. !      bss_mem_type=memtype;
  625. ! }
  626. ! #endif
  627. ! 
  628.   void add_cmdline_ref ();
  629.   
  630.   static struct option longopts[] =
  631.   {
  632. + #ifdef HUNK_INSTEAD_OF_A_OUT
  633. +   {"amiga-debug-hunk", 0, 0, 'a'},
  634. +   {"databss-together", 0, 0, 'b'},
  635. +   {"datadata-reloc", 0, 0, 'c'},
  636. +   {"msmall-code", 0, 0, 129},        /* ignore.. */
  637. +   {"flavor", 1, 0, 'f'},
  638. +   {"chip",2, 0, 'g'},
  639. +   {"fast",2, 0, 'h'},
  640. +   {"shortdata", 0, 0, 'm'},
  641. + #endif
  642.     {"d", 0, 0, 'd'},
  643.     {"dc", 0, 0, 'd'},        /* For Sun compatibility. */
  644. ***************
  645. *** 1208,1211 ****
  646. --- 1368,1384 ----
  647.        Also process most options completely.  */
  648.   
  649. + #ifdef amigados
  650. +   /* Phil.B: 27-Feb-94 default is to strip all symbols if LDSTRIP is set */
  651. +   if (getenv("LDSTRIP"))
  652. +     strip_symbols = STRIP_ALL;
  653. + 
  654. +   /* G.Nikl: 10-Jun-94 if LDSHORTDATA is found a "short" data hunk will be
  655. +      created. bss will be allocated via the hunk header. default is to dump
  656. +      the bss part in the data area as zeros */
  657. + 
  658. +   if (getenv("LDSHORTDATA"))
  659. +     long_data_hunk = 0;
  660. + #endif /* amigados */
  661. + 
  662.     while ((optc = getopt_long_only (argc, argv, SHORTOPTS, longopts, &longind))
  663.        != EOF)
  664. ***************
  665. *** 1225,1228 ****
  666. --- 1398,1415 ----
  667.         break;
  668.   
  669. + #ifdef HUNK_INSTEAD_OF_A_OUT
  670. +     case 'a':
  671. +       amiga_symbols_only = 0;
  672. +       break;
  673. + 
  674. +     case 'b':
  675. +       databss_together = 1;
  676. +       break;
  677. + 
  678. +     case 'c':
  679. +       output_datadata_relocs = 1;
  680. +       break;
  681. + #endif
  682. + 
  683.       case 'd':
  684.         force_common_definition = 1;
  685. ***************
  686. *** 1237,1244 ****
  687. --- 1424,1450 ----
  688.         break;
  689.   
  690. +     case 'f':
  691. +       n_flavors++;
  692. +       flavors = (char **) xrealloc (flavors, n_flavors * sizeof (char *));
  693. +       flavors[n_flavors - 1] = optarg;
  694. +       break;
  695. + 
  696. + #ifdef HUNK_INSTEAD_OF_A_OUT
  697. +     case 'g':
  698. +       set_mem_type(optarg,1<<30);
  699. +       break;
  700. + 
  701. +     case 'h':
  702. +       set_mem_type(optarg,2<<30);
  703. +       break;
  704. + #endif
  705.       case 'l':
  706.         number_of_files++;
  707.         break;
  708.   
  709. +     case 'm':
  710. +       long_data_hunk = 0;
  711. +       break;
  712. + 
  713.       case 'n':
  714.         if (output_style && output_style != OUTPUT_READONLY_TEXT)
  715. ***************
  716. *** 1364,1367 ****
  717. --- 1570,1583 ----
  718.       }
  719.   
  720. +   if (n_flavors > 1)
  721. +     {
  722. +       register int i;
  723. + 
  724. +       if (trace_files)
  725. +         for (i=0; i<n_flavors; i++)
  726. +       fprintf (stderr, "Flavor #%d : %s\n", i, flavors[i]);
  727. +       qsort (flavors, n_flavors, sizeof (char *), compare_strings);
  728. +     }
  729. + 
  730.     if (!number_of_files)
  731.       usage ("no input files", 0);
  732. ***************
  733. *** 1434,1438 ****
  734.       }
  735.   }
  736. ! 
  737.   
  738.   void
  739. --- 1650,1654 ----
  740.       }
  741.   }
  742. ! 
  743.   
  744.   void
  745. ***************
  746. *** 1479,1483 ****
  747.     return 0;
  748.   }
  749. ! 
  750.   /* Convenient functions for operating on one or all files being
  751.      loaded.  */
  752. --- 1695,1699 ----
  753.     return 0;
  754.   }
  755. ! 
  756.   /* Convenient functions for operating on one or all files being
  757.      loaded.  */
  758. ***************
  759. *** 1603,1608 ****
  760.         for (i = 0; i < n_search_dirs; i++)
  761.       {
  762. !       register char *string
  763. !         = concat (search_dirs[i], "/", entry->filename);
  764.         desc = open (string, O_RDONLY, 0);
  765.         if (desc > 0)
  766. --- 1819,1835 ----
  767.         for (i = 0; i < n_search_dirs; i++)
  768.       {
  769. !       register char *string;
  770. ! 
  771. !       string = search_dirs[i];
  772. !       if (n_flavors > 0)
  773. !         {
  774. !           int count;
  775. !           for (count = 0; count < n_flavors; count++)
  776. !         {
  777. !           string = concat (string, "/", flavors[count]);
  778. !         }
  779. !         }
  780. !       string = concat (string, "/", entry->filename);
  781. !       if (trace_files) fprintf (stderr, "Look for %s\n", string);
  782.         desc = open (string, O_RDONLY, 0);
  783.         if (desc > 0)
  784. ***************
  785. *** 1614,1617 ****
  786. --- 1841,1879 ----
  787.         free (string);
  788.       }
  789. +       /* Phil.B 30-Jul-94 if we couldn't find file using serch_dirs
  790. +      then we try removing trailing path one by one */
  791. +       if ((desc <= 0) && (n_flavors > 0))
  792. +     {
  793. +           if (trace_files) fprintf (stderr, "Climbing into flavors\n");
  794. +           for (i = 0; i < n_search_dirs; i++)
  795. +         {
  796. +           register int j;
  797. +           register char *string;
  798. + 
  799. +           for (j = n_flavors; j >= 0; j--)
  800. +                 {
  801. +                   int count;
  802. +               string = search_dirs[i];
  803. +           /* Phil.B 29-Jul-94 Special condition is made so that
  804. +              if j = 0 we don't copy flavor because we want to test
  805. +              search path without any flavor added. */
  806. +               for (count = 1; count <= j ; count++)
  807. +             {
  808. +               string = concat (string, "/", flavors[count-1]);
  809. +             }
  810. +               string = concat (string, "/", entry->filename);
  811. +               if (trace_files) fprintf (stderr, "Look for %s\n", string);
  812. +               desc = open (string, O_RDONLY, 0);
  813. +               if (desc > 0)
  814. +                 {
  815. +                   entry->filename = string;
  816. +                   entry->search_dirs_flag = 0;
  817. +                   break;
  818. +                 }
  819. +               free (string);
  820. +                 }
  821. +           if (desc > 0) break;
  822. +         }
  823. +         }
  824.       }
  825.     else
  826. ***************
  827. *** 1679,1683 ****
  828.     return result;
  829.   }
  830. ! 
  831.   /* Medium-level input routines for rel files.  */
  832.   
  833. --- 1941,1945 ----
  834.     return result;
  835.   }
  836. ! 
  837.   /* Medium-level input routines for rel files.  */
  838.   
  839. ***************
  840. *** 2045,2049 ****
  841.       fatal_with_file ("premature end of file in strings of ", entry);
  842.   }
  843. ! 
  844.   /* Read in the symbols of all input files.  */
  845.   
  846. --- 2307,2311 ----
  847.       fatal_with_file ("premature end of file in strings of ", entry);
  848.   }
  849. ! 
  850.   /* Read in the symbols of all input files.  */
  851.   
  852. ***************
  853. *** 2098,2102 ****
  854.     file_close ();
  855.   }
  856. ! 
  857.   /* Enter the external symbol defs and refs of ENTRY in the hash table.  */
  858.   
  859. --- 2360,2364 ----
  860.     file_close ();
  861.   }
  862. ! 
  863.   /* Enter the external symbol defs and refs of ENTRY in the hash table.  */
  864.   
  865. ***************
  866. *** 2121,2124 ****
  867. --- 2383,2396 ----
  868.       {
  869.         set_symbol_count++;
  870. + 
  871. + /* Matthias Fleischer 25-Apr-94: fix bug in ld that prevents
  872. +    symboltables for objects in the data hunk from working. */
  873. + #ifdef HUNK_INSTEAD_OF_A_OUT
  874. +         /* Count pointers in the symbol table, too */
  875. +       if ((p->n_type&~N_EXT)==N_SETD||
  876. +               (p->n_type&~N_EXT)==N_SETB)
  877. +         numdatadata_relocs++;
  878. + #endif
  879. + 
  880.         if (output_style != OUTPUT_RELOCATABLE)
  881.           enter_global_ref (p, p->n_un.n_strx + entry->strings, entry);
  882. ***************
  883. *** 2376,2380 ****
  884.   }
  885.   
  886. ! 
  887.   /* Searching libraries */
  888.   
  889. --- 2648,2652 ----
  890.   }
  891.   
  892. ! 
  893.   /* Searching libraries */
  894.   
  895. ***************
  896. *** 2453,2458 ****
  897. --- 2725,2755 ----
  898.          namelen++);
  899.   
  900. + /* JPB, 7 Jun 1992: Support for long file names. Set the global variable
  901. +                     ar_hdr_size to the real length of the header.
  902. +                     The code for extracting the long name is pretty much stolen
  903. +                     from the BSD ar (archive.c, version 5.7).
  904. +                     This is a *really* ugly hack!
  905. + */
  906. + #if 1
  907. +   ar_hdr_size = sizeof(struct ar_hdr);
  908. +   if (!bcmp(hdr1.ar_name,AR_EFMT1,sizeof(AR_EFMT1) -1))
  909. +   {
  910. +     namelen = atoi(hdr1.ar_name + sizeof(AR_EFMT1) -1);
  911. +     if (namelen <= 0 || namelen > MAXNAMLEN)
  912. +       fatal_with_file("malformatted long name of archive member in ",library_entry);
  913. +     ar_hdr_size += namelen;
  914. +     name = (char *) xmalloc (namelen+1);
  915. +     if (read(desc,name,namelen) != namelen)
  916. +       fatal_with_file("malformatted long name of archive member in ",library_entry);
  917. +   }
  918. +   else
  919. +   {
  920. +     name = (char *) xmalloc (namelen+1);
  921. +     strncpy (name, hdr1.ar_name, namelen);
  922. +   }
  923. + #else
  924.     name = (char *) xmalloc (namelen+1);
  925.     strncpy (name, hdr1.ar_name, namelen);
  926. + #endif
  927.     name[namelen] = 0;
  928.   
  929. ***************
  930. *** 2462,2466 ****
  931. --- 2759,2767 ----
  932.     subentry->strings = 0;
  933.     subentry->subfiles = 0;
  934. + #if 1
  935. +   subentry->starting_offset = subfile_offset + ar_hdr_size;
  936. + #else
  937.     subentry->starting_offset = subfile_offset + sizeof hdr1;
  938. + #endif
  939.     subentry->superfile = library_entry;
  940.     subentry->library_flag = 0;
  941. ***************
  942. *** 2474,2478 ****
  943.     return subentry;
  944.   }
  945. ! 
  946.   int subfile_wanted_p ();
  947.   
  948. --- 2775,2779 ----
  949.     return subentry;
  950.   }
  951. ! 
  952.   int subfile_wanted_p ();
  953.   
  954. ***************
  955. *** 2623,2627 ****
  956.     free (symdef_data);
  957.   }
  958. ! 
  959.   
  960.   /* Handle a subentry for a file with no __.SYMDEF. */
  961. --- 2924,2928 ----
  962.     free (symdef_data);
  963.   }
  964. ! 
  965.   
  966.   /* Handle a subentry for a file with no __.SYMDEF. */
  967. ***************
  968. *** 2676,2684 ****
  969.   
  970.         process_subentry (desc, subentry, entry, &prev);
  971.         this_subfile_offset += member_length + sizeof (struct ar_hdr);
  972.         if (this_subfile_offset & 1) this_subfile_offset++;
  973.       }
  974.   }
  975. ! 
  976.   /* ENTRY is an entry for a library member.
  977.      Its symbols have been read into core, but not entered.
  978. --- 2977,2993 ----
  979.   
  980.         process_subentry (desc, subentry, entry, &prev);
  981. + #if 1
  982. + /* JPB, 7 Jun 1992: Can't count on sizeof(ar_hdr) to be the size of the entire
  983. +                     header: Long names extends the header. This is a *really*
  984. +                     ugly hack, using a global variable! */
  985. + 
  986. +       this_subfile_offset += member_length + ar_hdr_size;
  987. + #else
  988.         this_subfile_offset += member_length + sizeof (struct ar_hdr);
  989. + #endif
  990.         if (this_subfile_offset & 1) this_subfile_offset++;
  991.       }
  992.   }
  993. ! 
  994.   /* ENTRY is an entry for a library member.
  995.      Its symbols have been read into core, but not entered.
  996. ***************
  997. *** 2778,2782 ****
  998.     return 0;
  999.   }
  1000. ! 
  1001.   void consider_file_section_lengths (), relocate_file_addresses ();
  1002.   
  1003. --- 3087,3091 ----
  1004.     return 0;
  1005.   }
  1006. ! 
  1007.   void consider_file_section_lengths (), relocate_file_addresses ();
  1008.   
  1009. ***************
  1010. *** 2801,2805 ****
  1011. --- 3110,3118 ----
  1012.     initialize_text_start ();
  1013.   
  1014. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1015. +   text_size = 0;
  1016. + #else
  1017.     text_size = text_header_size;
  1018. + #endif
  1019.   
  1020.     /* Compute total size of sections */
  1021. ***************
  1022. *** 2810,2813 ****
  1023. --- 3123,3127 ----
  1024.        Include the padding in the text segment size.  */
  1025.   
  1026. + #ifndef HUNK_INSTEAD_OF_A_OUT
  1027.     if (output_style == OUTPUT_READONLY_TEXT || output_style == OUTPUT_DEMAND_PAGED)
  1028.       {
  1029. ***************
  1030. *** 2815,2818 ****
  1031. --- 3129,3145 ----
  1032.         text_size += text_pad;
  1033.       }
  1034. + #endif
  1035. + 
  1036. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1037. +   /* they go into text if they are required */
  1038. +   if (output_datadata_relocs && numdatadata_relocs)
  1039. +     {
  1040. +       if (datadata_reloc_symbol)
  1041. +         datadata_reloc_symbol->value = text_size;
  1042. +       
  1043. +       /* 1 long for the size, then the vector */
  1044. +       text_size += (1 + numdatadata_relocs) * 4;
  1045. +     }
  1046. + #endif
  1047.   
  1048.     /* Now that the text_size is known, initialize the data start address;
  1049. ***************
  1050. *** 2821,2824 ****
  1051. --- 3148,3157 ----
  1052.     initialize_data_start ();
  1053.   
  1054. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1055. +   data_pad = 0;
  1056. + #endif
  1057. + 
  1058. + 
  1059. + #ifndef HUNK_INSTEAD_OF_A_OUT
  1060.     /* Make sure bss starts out aligned as much as anyone can want.  */
  1061.     {
  1062. ***************
  1063. *** 2828,2831 ****
  1064. --- 3161,3165 ----
  1065.       data_size = new_data_size;
  1066.     }
  1067. + #endif
  1068.   
  1069.     /* Set up the set element vector */
  1070. ***************
  1071. *** 2837,2845 ****
  1072. --- 3171,3189 ----
  1073.        vector, plus a word for each symbol for a zero at the end of
  1074.        the vector (for incremental linking).  */
  1075. + #if 0
  1076. +       /* I think this is the other way round !? ### mw */
  1077. + 
  1078.         set_sect_size
  1079.       = (2 * set_symbol_count + set_vector_count) * sizeof (unsigned long);
  1080. + #else
  1081. +       set_sect_size
  1082. +     = (2 * set_vector_count + set_symbol_count) * sizeof (unsigned long);
  1083. + #endif
  1084.         set_sect_start = data_start + data_size;
  1085.         data_size += set_sect_size;
  1086.         set_vectors = (unsigned long *) xmalloc (set_sect_size);
  1087. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1088. +       rel_vectors = (unsigned char *) xmalloc (set_sect_size/sizeof(unsigned long));
  1089. + #endif
  1090.         setv_fill_count = 0;
  1091.       }
  1092. ***************
  1093. *** 2889,2893 ****
  1094. --- 3233,3253 ----
  1095.                 multiple_def_count++;
  1096.               }
  1097. + 
  1098. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1099. +           /* don't relocate absolute symbols in sets */
  1100. +           rel_vectors[setv_fill_count] = ( ((type & ~N_EXT) != N_SETA) );
  1101. + 
  1102. +           /* Matthias Fleischer 25-Apr-94: fix bug in ld that prevents
  1103. +              symboltables for objects in the data hunk from working. */
  1104. + 
  1105. +           /* This is some kind of hack, but doing this cleaner would be 
  1106. +              much more complicated */
  1107. +           set_vectors[setv_fill_count++] = p->n_value
  1108. +             +( (type & ~N_EXT) == N_SETD ? text_size : 0 )
  1109. +             +( (type & ~N_EXT) == N_SETB ? data_size : 0 );
  1110. + #else          
  1111.             set_vectors[setv_fill_count++] = p->n_value;
  1112. + #endif
  1113. + 
  1114.           }
  1115.             else if ((type & N_EXT) && type != (N_UNDF | N_EXT))
  1116. ***************
  1117. *** 2932,2936 ****
  1118. --- 3292,3302 ----
  1119.                     - data_size - data_start);
  1120.   
  1121. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1122. +           sp->value = bss_size;
  1123. +           if (databss_together)
  1124. +             sp->value += data_start + data_size;
  1125. + #else
  1126.             sp->value = data_start + data_size + bss_size;
  1127. + #endif
  1128.             sp->defined = N_BSS | N_EXT;
  1129.             bss_size += com;
  1130. ***************
  1131. *** 2952,2955 ****
  1132. --- 3318,3322 ----
  1133.           = (sp->value - set_sect_start) / sizeof (unsigned long);
  1134.             unsigned long i, tmp;
  1135. +           unsigned char tmp2;
  1136.   
  1137.             set_vectors[length_word_index]
  1138. ***************
  1139. *** 2965,2968 ****
  1140. --- 3332,3342 ----
  1141.               = set_vectors[setv_fill_count - i];
  1142.             set_vectors[setv_fill_count - i] = tmp;
  1143. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1144. +           /* reverse relocation vector too! */
  1145. +           tmp2 = rel_vectors[length_word_index + i];
  1146. +           rel_vectors[length_word_index + i]
  1147. +             = rel_vectors[setv_fill_count - i];
  1148. +           rel_vectors[setv_fill_count - i] = tmp2;
  1149. + #endif
  1150.           }
  1151.   
  1152. ***************
  1153. *** 2995,2998 ****
  1154. --- 3369,3385 ----
  1155.     }
  1156.   
  1157. + #ifdef amigados
  1158. +   {
  1159. +     if (sdata_symbol)
  1160. +       sdata_symbol->value = data_start;
  1161. +     if (text_size_symbol)
  1162. +       text_size_symbol->value = text_size;
  1163. +     if (data_size_symbol)
  1164. +       data_size_symbol->value = data_size;
  1165. +     if (bss_size_symbol)
  1166. +       bss_size_symbol->value  = bss_size;
  1167. +   }
  1168. + #endif
  1169. + 
  1170.     {
  1171.       int edata_value = data_start + data_size;
  1172. ***************
  1173. *** 3014,3020 ****
  1174. --- 3401,3409 ----
  1175.         data_pad_additional = specified_data_size - data_size;
  1176.   
  1177. + #ifndef HUNK_INSTEAD_OF_A_OUT
  1178.       if (output_style == OUTPUT_DEMAND_PAGED)
  1179.         data_pad_additional =
  1180.       ((data_pad_additional + data_size + page_size - 1) & (- page_size)) - data_size;
  1181. + #endif
  1182.   
  1183.       bss_size -= data_pad_additional;
  1184. ***************
  1185. *** 3025,3030 ****
  1186.       data_pad += data_pad_additional;
  1187.     }
  1188.   }
  1189. ! 
  1190.   /* Accumulate the section sizes of input file ENTRY
  1191.      into the section sizes of the output file.  */
  1192. --- 3414,3451 ----
  1193.       data_pad += data_pad_additional;
  1194.     }
  1195. + 
  1196. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1197. +   /* if there is some code, assign it next hunk_number */
  1198. +   if (text_size)
  1199. +      number_of_code_hunk = current_hunk++;
  1200. +   else
  1201. +      number_of_code_hunk = -1;
  1202. + 
  1203. +   if (data_size)
  1204. +      number_of_data_hunk = current_hunk++;
  1205. +   else
  1206. +      number_of_data_hunk = -1;
  1207. + 
  1208. +   if (bss_size)
  1209. +      number_of_bss_hunk  = current_hunk++;
  1210. +   else
  1211. +      number_of_bss_hunk  = -1;
  1212. + 
  1213. +   if (databss_together)
  1214. +     {
  1215. +       if (data_size && bss_size)
  1216. +     {
  1217. +       current_hunk --;
  1218. +       number_of_bss_hunk = number_of_data_hunk;
  1219. +     }
  1220. +     }
  1221. + 
  1222. +   if (strip_symbols != STRIP_ALL && !amiga_symbols_only)
  1223. +      number_of_debug_hunk = current_hunk++;
  1224. +   else
  1225. +      number_of_debug_hunk = -1;
  1226. + #endif
  1227.   }
  1228. ! 
  1229.   /* Accumulate the section sizes of input file ENTRY
  1230.      into the section sizes of the output file.  */
  1231. ***************
  1232. *** 3047,3050 ****
  1233. --- 3468,3495 ----
  1234.     text_reloc_size += entry->text_reloc_size;
  1235.     data_reloc_size += entry->data_reloc_size;
  1236. + 
  1237. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1238. +   if (! output_datadata_relocs)
  1239. +     return;
  1240. + 
  1241. +   /* have to guess at how many datadata-relocs we might have. This number
  1242. +      is larger than the real thing, because I have to include the references
  1243. +      to UNDF symbols as well. */
  1244. +   {
  1245. +     struct relocation_info *r, *re, *reloc;
  1246. +     int desc = file_open (entry);
  1247. + 
  1248. +     reloc = (struct relocation_info *) alloca (entry->data_reloc_size);
  1249. +     lseek (desc, entry->starting_offset + entry->data_reloc_offset, L_SET);
  1250. +     if (entry->data_reloc_size != read (desc, reloc, entry->data_reloc_size))
  1251. +       fatal_with_file ("premature eof in data relocation of ", entry);
  1252. +     
  1253. +     for (r = reloc, re = reloc + entry->data_reloc_size/sizeof(*re); r < re; r++)
  1254. +       if (RELOC_EXTERN_P (r) || ((RELOC_TYPE (r) & N_TYPE) != N_TEXT))
  1255. +     numdatadata_relocs ++;
  1256. + 
  1257. +     file_close ();
  1258. +   }
  1259. + #endif
  1260.   }
  1261.   
  1262. ***************
  1263. *** 3063,3067 ****
  1264.        been, we would get the wrong results here.  */
  1265.     entry->data_start_address += data_start;
  1266. !   entry->bss_start_address += data_start + data_size;
  1267.   
  1268.     {
  1269. --- 3508,3517 ----
  1270.        been, we would get the wrong results here.  */
  1271.     entry->data_start_address += data_start;
  1272. ! 
  1273. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1274. !   if (databss_together)
  1275. ! #endif
  1276. !     entry->bss_start_address += data_start + data_size;
  1277. ! 
  1278.   
  1279.     {
  1280. ***************
  1281. *** 3081,3086 ****
  1282.           p->n_value += entry->text_start_address - entry->orig_text_address;
  1283.           break;
  1284. -       case N_DATA:
  1285.         case N_SETV:
  1286.         case N_SETD:
  1287.           /* Data segment symbol.  Subtract the address of the
  1288. --- 3531,3536 ----
  1289.           p->n_value += entry->text_start_address - entry->orig_text_address;
  1290.           break;
  1291.         case N_SETV:
  1292. +       case N_DATA:
  1293.         case N_SETD:
  1294.           /* Data segment symbol.  Subtract the address of the
  1295. ***************
  1296. *** 3099,3103 ****
  1297.     }
  1298.   }
  1299. ! 
  1300.   void describe_file_sections (), list_file_locals ();
  1301.   
  1302. --- 3549,3553 ----
  1303.     }
  1304.   }
  1305. ! 
  1306.   void describe_file_sections (), list_file_locals ();
  1307.   
  1308. ***************
  1309. *** 3175,3179 ****
  1310.   }
  1311.   
  1312. ! 
  1313.   /* Static vars for do_warnings and subroutines of it */
  1314.   int list_unresolved_refs;    /* List unresolved refs */
  1315. --- 3625,3629 ----
  1316.   }
  1317.   
  1318. ! 
  1319.   /* Static vars for do_warnings and subroutines of it */
  1320.   int list_unresolved_refs;    /* List unresolved refs */
  1321. ***************
  1322. *** 3193,3197 ****
  1323.   };
  1324.   
  1325. - void qsort ();
  1326.   /*
  1327.    * Helper routines for do_file_warnings.
  1328. --- 3643,3646 ----
  1329. ***************
  1330. *** 3673,3677 ****
  1331.     entry->strings = 0;        /* Since it will dissapear anyway.  */
  1332.   }
  1333. ! 
  1334.   do_warnings (outfile)
  1335.        FILE *outfile;
  1336. --- 4122,4126 ----
  1337.     entry->strings = 0;        /* Since it will dissapear anyway.  */
  1338.   }
  1339. ! 
  1340.   do_warnings (outfile)
  1341.        FILE *outfile;
  1342. ***************
  1343. *** 3692,3696 ****
  1344.       make_executable = 0;
  1345.   }
  1346. ! 
  1347.   #ifdef A_OUT
  1348.   
  1349. --- 4141,4145 ----
  1350.       make_executable = 0;
  1351.   }
  1352. ! 
  1353.   #ifdef A_OUT
  1354.   
  1355. ***************
  1356. *** 3713,3716 ****
  1357. --- 4162,4170 ----
  1358.     int magic;
  1359.   
  1360. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1361. +   text_start = 0;
  1362. +   return;
  1363. + #endif
  1364. + 
  1365.     switch (output_style)
  1366.       {
  1367. ***************
  1368. *** 3771,3774 ****
  1369. --- 4225,4233 ----
  1370.   initialize_a_out_data_start ()
  1371.   {
  1372. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1373. +   data_start = 0;
  1374. +   return;
  1375. + #endif
  1376. + 
  1377.     outheader.a_text = text_size;
  1378.   #ifdef sequent
  1379. ***************
  1380. *** 3924,3935 ****
  1381.   write_a_out_header ()
  1382.   {
  1383. !   lseek (outdesc, 0L, 0);
  1384.   
  1385.   #ifdef COFF_ENCAPSULATE
  1386.     if (need_coff_header)
  1387. !     mywrite (&coffheader, sizeof coffheader, 1, outdesc);
  1388.   #endif
  1389.   
  1390. !   mywrite (&outheader, sizeof (struct exec), 1, outdesc);
  1391.   
  1392.     /* Output whatever padding is required in the executable file
  1393. --- 4383,4394 ----
  1394.   write_a_out_header ()
  1395.   {
  1396. !   fseek (outstream, 0L, 0);
  1397.   
  1398.   #ifdef COFF_ENCAPSULATE
  1399.     if (need_coff_header)
  1400. !     mywrite (&coffheader, sizeof coffheader, 1, outstream);
  1401.   #endif
  1402.   
  1403. !   mywrite (&outheader, sizeof (struct exec), 1, outstream);
  1404.   
  1405.     /* Output whatever padding is required in the executable file
  1406. ***************
  1407. *** 3937,3946 ****
  1408.   
  1409.   #ifndef COFF_ENCAPSULATE
  1410. !   padfile (N_TXTOFF (outheader) - sizeof outheader, outdesc);
  1411.   #endif
  1412.   }
  1413.   
  1414.   #endif
  1415. ! 
  1416.   #ifdef MACH_O
  1417.   
  1418. --- 4396,4405 ----
  1419.   
  1420.   #ifndef COFF_ENCAPSULATE
  1421. !   padfile (N_TXTOFF (outheader) - sizeof outheader, outstream);
  1422.   #endif
  1423.   }
  1424.   
  1425.   #endif
  1426. ! 
  1427.   #ifdef MACH_O
  1428.   
  1429. ***************
  1430. *** 4146,4150 ****
  1431.     thread_state state;
  1432.   
  1433. !   lseek (outdesc, 0L, 0);
  1434.   
  1435.   
  1436. --- 4605,4609 ----
  1437.     thread_state state;
  1438.   
  1439. !   fseek (outstream, 0L, 0);
  1440.   
  1441.   
  1442. ***************
  1443. *** 4252,4256 ****
  1444.         m_object.symseg = symseg;
  1445.   #endif
  1446. !       mywrite((char *) &m_object, 1, sizeof m_object, outdesc);
  1447.         break;
  1448.   
  1449. --- 4711,4715 ----
  1450.         m_object.symseg = symseg;
  1451.   #endif
  1452. !       mywrite((char *) &m_object, 1, sizeof m_object, outstream);
  1453.         break;
  1454.   
  1455. ***************
  1456. *** 4306,4310 ****
  1457.         m_exec.symseg = symseg;
  1458.   #endif
  1459. !       mywrite((char *) &m_exec, 1, sizeof m_exec, outdesc);
  1460.         break;
  1461.       }
  1462. --- 4765,4769 ----
  1463.         m_exec.symseg = symseg;
  1464.   #endif
  1465. !       mywrite((char *) &m_exec, 1, sizeof m_exec, outstream);
  1466.         break;
  1467.       }
  1468. ***************
  1469. *** 4387,4391 ****
  1470.   
  1471.   #endif
  1472. ! 
  1473.   /* The following functions are simple switches according to the
  1474.      output style.  */
  1475. --- 4846,4850 ----
  1476.   
  1477.   #endif
  1478. ! 
  1479.   /* The following functions are simple switches according to the
  1480.      output style.  */
  1481. ***************
  1482. *** 4485,4488 ****
  1483. --- 4944,4951 ----
  1484.   write_header ()
  1485.   {
  1486. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1487. +   conditionally_rewrite_headers ();
  1488. +   return;
  1489. + #else
  1490.   #ifdef A_OUT
  1491.     if (output_file_type == IS_A_OUT)
  1492. ***************
  1493. *** 4499,4505 ****
  1494.       }
  1495.   #endif
  1496.     fatal ("unknown output file type (enum file_type)", (char *) 0);
  1497.   }
  1498. ! 
  1499.   /* Write the output file */
  1500.   
  1501. --- 4962,4969 ----
  1502.       }
  1503.   #endif
  1504. + #endif
  1505.     fatal ("unknown output file type (enum file_type)", (char *) 0);
  1506.   }
  1507. ! 
  1508.   /* Write the output file */
  1509.   
  1510. ***************
  1511. *** 4520,4539 ****
  1512.     (void) unlink (output_filename);
  1513.     
  1514. !   outdesc = open (output_filename, O_WRONLY | O_CREAT | O_TRUNC, 0666);
  1515. !   if (outdesc < 0) perror_name (output_filename);
  1516.   
  1517. !   if (fstat (outdesc, &statbuf) < 0)
  1518.       perror_name (output_filename);
  1519.   
  1520.     filemode = statbuf.st_mode;
  1521.   
  1522.     chmod (output_filename, filemode & ~0111);
  1523.   
  1524.     /* Calculate the offsets of the various pieces of the output file.  */
  1525.     compute_section_offsets ();
  1526.   
  1527.     /* Output the text and data segments, relocating as we go.  */
  1528.     write_text ();
  1529.     write_data ();
  1530.   
  1531.     /* Output the merged relocation info, if requested with `-r'.  */
  1532. --- 4984,5049 ----
  1533.     (void) unlink (output_filename);
  1534.     
  1535. !   outstream = fopen (output_filename, "w");
  1536. !   if (outstream == 0) perror_name (output_filename);
  1537.   
  1538. ! #ifndef MCH_AMIGA
  1539. !   if (fstat (fileno (outstream), &statbuf) < 0)
  1540.       perror_name (output_filename);
  1541.   
  1542.     filemode = statbuf.st_mode;
  1543.   
  1544. +   /* this wouldn't work anyway, "file in use, error"... */
  1545.     chmod (output_filename, filemode & ~0111);
  1546. + #endif
  1547. + 
  1548. +   /* on the Amiga, the following call DOES set the symbol offset, but
  1549. +    * it does it wrong, we'll be able to do it right, as soon as all the
  1550. +    * other data has been written.. */
  1551.   
  1552.     /* Calculate the offsets of the various pieces of the output file.  */
  1553.     compute_section_offsets ();
  1554.   
  1555. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1556. +   /* get ready to collect information where all symbols
  1557. +    * go. Since this has to be done only once, we'll later be able to 
  1558. +    * output the right symbol-hunk after the right (code/data/bss-)hunk. */
  1559. +   init_symbol_hunks ();
  1560. +   look_for_symbols ();
  1561. + #endif
  1562. + 
  1563.     /* Output the text and data segments, relocating as we go.  */
  1564.     write_text ();
  1565.     write_data ();
  1566. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1567. +   if (datadata_relocs_offset)
  1568. +     write_datadata_relocs ();
  1569. + 
  1570. +   write_bss ();
  1571. +   if (number_of_debug_hunk != -1)
  1572. +     {
  1573. +       /* ok, lets output the start of the debug hunk */
  1574. +       fseek (outstream, 0L, SEEK_END);
  1575. +       offset_of_debug_hunk = ftell (outstream);
  1576. + 
  1577. +       dh.id = 0x3f1;     /* HUNK_DEBUG */
  1578. +       dh.len = 0;        /* we'll fill this in later */
  1579. +       dh.magic = ZMAGIC; /* when wishes came true... */
  1580. +       dh.syms = outheader.a_syms;
  1581. +       mywrite(&dh, sizeof dh, 1, outstream);
  1582. + 
  1583. +       output_syms_offset   = ftell (outstream);
  1584. +       output_strs_offset   = output_syms_offset + dh.syms;
  1585. + 
  1586. +       /* since we later will seek forward and backward to fill in each files
  1587. +        * symbol- and string-table, we have to create the needed space, that
  1588. +        * will be seeked over, since on an empty file, lseek(fd, 10, 0) will 
  1589. +        * position to byte 10 on Unix, but will just generate an error under
  1590. +        * AmigaDOS and stay at position 0. */
  1591. + 
  1592. +       /* this will just write garbage, but thats enough:-)) */
  1593. +       mywrite(&output_strs_offset, dh.syms+4, 1, outstream);
  1594. +       fseek (outstream, output_syms_offset, 0);
  1595. +     }
  1596. + #endif
  1597.   
  1598.     /* Output the merged relocation info, if requested with `-r'.  */
  1599. ***************
  1600. *** 4548,4559 ****
  1601.     compute_more_section_offsets ();
  1602.   
  1603.     /* Copy any GDB symbol segments from input files.  */
  1604.     write_symsegs ();
  1605.   
  1606.     /* Now that everything is known about the output file, write its header.  */
  1607.     write_header ();
  1608.   
  1609. !   close (outdesc);
  1610.   
  1611.     mask = umask (0);
  1612.     umask (mask);
  1613. --- 5058,5077 ----
  1614.     compute_more_section_offsets ();
  1615.   
  1616. + #ifndef HUNK_INSTEAD_OF_A_OUT
  1617. +   /* I don't support GDB-symbol segments, they aren't used anymore by
  1618. +    * the newer versions of gdb, BUT of course, if somebody needs them..
  1619. +    * that's exactly why I introduced the "dh.strs" Parameter, so that
  1620. +    * you could - as in Unix - append these segments at the end of the file */
  1621. + 
  1622.     /* Copy any GDB symbol segments from input files.  */
  1623.     write_symsegs ();
  1624. + #endif
  1625.   
  1626.     /* Now that everything is known about the output file, write its header.  */
  1627.     write_header ();
  1628.   
  1629. !   fclose (outstream);
  1630.   
  1631. + #ifndef HUNK_INSTEAD_OF_A_OUT
  1632.     mask = umask (0);
  1633.     umask (mask);
  1634. ***************
  1635. *** 4561,4567 ****
  1636.     if (chmod (output_filename, filemode | (0111 & ~mask)) == -1)
  1637.       perror_name (output_filename);
  1638.   }
  1639. ! 
  1640.   void modify_location (), perform_relocation (), copy_text (), copy_data ();
  1641.   
  1642.   /* Relocate the text segment of each input file
  1643. --- 5079,5089 ----
  1644.     if (chmod (output_filename, filemode | (0111 & ~mask)) == -1)
  1645.       perror_name (output_filename);
  1646. + #endif
  1647.   }
  1648. ! 
  1649.   void modify_location (), perform_relocation (), copy_text (), copy_data ();
  1650. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1651. + void write_hunk_header();
  1652. + #endif
  1653.   
  1654.   /* Relocate the text segment of each input file
  1655. ***************
  1656. *** 4574,4580 ****
  1657.       fprintf (stderr, "Copying and relocating text:\n\n");
  1658.   
  1659. !   lseek (outdesc, output_text_offset + text_header_size, 0);
  1660.   
  1661.     each_full_file (copy_text, 0);
  1662.     file_close ();
  1663.   
  1664. --- 5096,5133 ----
  1665.       fprintf (stderr, "Copying and relocating text:\n\n");
  1666.   
  1667. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1668. !   /* this is a definitive write, we don't need to rewrite this out, since
  1669. !    * the yet undefined sizes of the reloc-hunks don't go into the 
  1670. !    * header-hunk */
  1671. !   write_hunk_header(outstream);
  1672. !   init_reloc_hunk();
  1673. ! 
  1674. !   /* and if there's no code-hunk, we can return here.. no sense in
  1675. !    * complicately doing just nothing... */
  1676. !   if (number_of_code_hunk == -1) return;
  1677. ! 
  1678. !   /* else start the code-hunk */
  1679. !   {
  1680. !      long code_header[2];
  1681. !      code_header[0] = 0x3e9;
  1682. !      code_header[1] = LONGSIZE(text_size);
  1683. !      mywrite(code_header, 1, sizeof code_header, outstream);
  1684. !   }
  1685. ! #else
  1686. !   fseek (outstream, output_text_offset + text_header_size, 0);
  1687. ! #endif
  1688.   
  1689.     each_full_file (copy_text, 0);
  1690. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1691. +   if (output_datadata_relocs && numdatadata_relocs)
  1692. +     {
  1693. +       int i, zero = 0;
  1694. +       /* include the size-field, -> <= . The `real' values come later */
  1695. +       datadata_relocs_offset = ftell (outstream);
  1696. +       for (i = 0; i <= numdatadata_relocs; i ++)
  1697. +         mywrite (&zero, 1, sizeof (long), outstream);
  1698. +     }
  1699. + #endif
  1700. + 
  1701.     file_close ();
  1702.   
  1703. ***************
  1704. *** 4582,4586 ****
  1705.       fprintf (stderr, "\n");
  1706.   
  1707. !   padfile (text_pad, outdesc);
  1708.   }
  1709.   
  1710. --- 5135,5148 ----
  1711.       fprintf (stderr, "\n");
  1712.   
  1713. !   padfile (text_pad, outstream);
  1714. ! 
  1715. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1716. !   write_reloc_hunk();
  1717. !   write_symbol_hunk(number_of_code_hunk);
  1718. !   {
  1719. !     long hunk_end = 0x3f2;
  1720. !     mywrite(&hunk_end, 1, sizeof(long), outstream);
  1721. !   }
  1722. ! #endif
  1723.   }
  1724.   
  1725. ***************
  1726. *** 4687,4691 ****
  1727.   
  1728.     /* Relocate the text according to the text relocation.  */
  1729. - 
  1730.     perform_relocation (bytes, entry->text_start_address - entry->orig_text_address,
  1731.                 entry->text_size, reloc, entry->text_reloc_size, entry);
  1732. --- 5249,5252 ----
  1733. ***************
  1734. *** 4693,4699 ****
  1735.     /* Write the relocated text to the output file.  */
  1736.   
  1737. !   mywrite (bytes, 1, entry->text_size, outdesc);
  1738.   }
  1739. ! 
  1740.   /* Relocate the data segment of each input file
  1741.      and write to the output file.  */
  1742. --- 5254,5260 ----
  1743.     /* Write the relocated text to the output file.  */
  1744.   
  1745. !   mywrite (bytes, 1, entry->text_size, outstream);
  1746.   }
  1747. ! 
  1748.   /* Relocate the data segment of each input file
  1749.      and write to the output file.  */
  1750. ***************
  1751. *** 4705,4709 ****
  1752.       fprintf (stderr, "Copying and relocating data:\n\n");
  1753.   
  1754. !   lseek (outdesc, output_data_offset, 0);
  1755.   
  1756.     each_full_file (copy_data, 0);
  1757. --- 5266,5290 ----
  1758.       fprintf (stderr, "Copying and relocating data:\n\n");
  1759.   
  1760. ! #ifndef HUNK_INSTEAD_OF_A_OUT
  1761. !   fseek (outstream, output_data_offset, 0);
  1762. ! #else
  1763. !   /* just have to hope that the file is positioned correctly.. */
  1764. !   init_reloc_hunk();
  1765. !   /* start a data-hunk, if there is data to be output */
  1766. !   if (number_of_data_hunk == -1) return;
  1767. ! 
  1768. !   {
  1769. !     long data_header[2];
  1770. !     int size;
  1771. !     data_header[0] = 0x3ea;
  1772. !     size = LONGSIZE(data_size);
  1773. !     /* create long data hunk? */
  1774. !     if (long_data_hunk && databss_together)
  1775. !       size=LONGSIZE(data_size+bss_size);
  1776. !     data_header[1] = size;
  1777. !       
  1778. !     mywrite(data_header, 1, sizeof data_header, outstream);
  1779. !   }
  1780. ! #endif
  1781.   
  1782.     each_full_file (copy_data, 0);
  1783. ***************
  1784. *** 4714,4724 ****
  1785.   
  1786.     if (set_vector_count)
  1787. !     mywrite (set_vectors, 2 * set_symbol_count + set_vector_count,
  1788. !          sizeof (unsigned long), outdesc);
  1789.   
  1790.     if (trace_files)
  1791.       fprintf (stderr, "\n");
  1792.   
  1793. !   padfile (data_pad, outdesc);
  1794.   }
  1795.   
  1796. --- 5295,5337 ----
  1797.   
  1798.     if (set_vector_count)
  1799. !     {
  1800. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1801. !      /* this and mywrite later: inverted set_symbol_count and 
  1802. !       * set_vector_count, guess they were mixed up before   ### mw */
  1803. ! 
  1804. !       relocate_set_vectors (set_vectors, rel_vectors,
  1805. !                 2 * set_vector_count + set_symbol_count);
  1806. ! #endif
  1807. ! #if 0
  1808. !       mywrite (set_vectors, 2 * set_symbol_count + set_vector_count,
  1809. !            sizeof (unsigned long), outstream);
  1810. ! #else
  1811. !       mywrite (set_vectors, 2 * set_vector_count + set_symbol_count,
  1812. !            sizeof (unsigned long), outstream);
  1813. ! #endif
  1814. !     }
  1815.   
  1816.     if (trace_files)
  1817.       fprintf (stderr, "\n");
  1818.   
  1819. !   padfile (data_pad, outstream);
  1820. ! 
  1821. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1822. ! 
  1823. !   if (long_data_hunk && databss_together && bss_size)
  1824. !     {
  1825. !       /* dump zeros */
  1826. !       int i, zero = 0;
  1827. !       for (i = 0; i < LONGSIZE(bss_size); i++)
  1828. !     mywrite (&zero, 1, sizeof (long), outstream);
  1829. !     }
  1830. ! 
  1831. !   write_reloc_hunk();
  1832. !   write_symbol_hunk(number_of_data_hunk);
  1833. !   {
  1834. !     long hunk_end = 0x3f2;
  1835. !     mywrite(&hunk_end, 1, sizeof(long), outstream);
  1836. !   }
  1837. ! #endif
  1838.   }
  1839.   
  1840. ***************
  1841. *** 4766,4775 ****
  1842.       fatal_with_file ("premature eof in data section of ", entry);
  1843.   
  1844. !   perform_relocation (bytes, entry->data_start_address - entry->orig_data_address,
  1845. !               entry->data_size, reloc, entry->data_reloc_size, entry);
  1846.   
  1847. !   mywrite (bytes, 1, entry->data_size, outdesc);
  1848.   }
  1849. ! 
  1850.   /* Relocate ENTRY's text or data section contents.
  1851.      DATA is the address of the contents, in core.
  1852. --- 5379,5392 ----
  1853.       fatal_with_file ("premature eof in data section of ", entry);
  1854.   
  1855. !   perform_relocation (bytes, entry->data_start_address 
  1856. ! #ifndef HUNK_INSTEAD_OF_A_OUT
  1857. !                         - entry->orig_data_address
  1858. ! #endif
  1859. !                                     ,
  1860. !                 entry->data_size, reloc, entry->data_reloc_size, entry);
  1861.   
  1862. !   mywrite (bytes, 1, entry->data_size, outstream);
  1863.   }
  1864. ! 
  1865.   /* Relocate ENTRY's text or data section contents.
  1866.      DATA is the address of the contents, in core.
  1867. ***************
  1868. *** 4797,4800 ****
  1869. --- 5414,5421 ----
  1870.     int bss_relocation = entry->bss_start_address - entry->orig_bss_address;
  1871.   
  1872. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1873. +   int this_hunk;
  1874. + #endif
  1875. + 
  1876.     for (; p < end; p++)
  1877.       {
  1878. ***************
  1879. *** 4802,4805 ****
  1880. --- 5423,5431 ----
  1881.         register int addr = RELOC_ADDRESS(p);
  1882.         register unsigned int mask = 0;
  1883. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1884. +       int ext_abs;
  1885. +       
  1886. +       ext_abs = 0;
  1887. + #endif
  1888.   
  1889.         if (addr >= data_size)
  1890. ***************
  1891. *** 4828,4831 ****
  1892. --- 5454,5489 ----
  1893.         else
  1894.           relocation = sp->value;
  1895. + 
  1896. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1897. +       if ((sp->defined & ~N_EXT) == N_ABS)
  1898. +         /* sort of a kludge.. the only external symbol (not pcrelative)
  1899. +              * we can really resolve.. */
  1900. +         ext_abs = 1;
  1901. +       else if ((sp->defined & ~N_EXT) == N_TEXT ||
  1902. +           (sp->defined & ~N_EXT) == N_SETT)
  1903. +         {
  1904. +           this_hunk = number_of_code_hunk;
  1905. +           if (RELOC_BASEREL_P (p))
  1906. +             {
  1907. +               fprintf (stderr, "symn = $%x, extern = %d, addr = $%lx.\n",
  1908. +                          p->r_symbolnum, p->r_extern, p->r_address);
  1909. +           fatal_with_file ("base relative text relocation in ", entry);
  1910. +         }
  1911. +         }
  1912. +       else if ((sp->defined & ~N_EXT) == N_DATA ||
  1913. +                (sp->defined & ~N_EXT) == N_SETD ||
  1914. +            (sp->defined & ~N_EXT) == N_SETV)
  1915. +         {
  1916. +           this_hunk = number_of_data_hunk;
  1917. +         }
  1918. +       else if ((sp->defined & ~N_EXT) == N_BSS ||
  1919. +            (sp->defined & ~N_EXT) == N_UNDF ||
  1920. +                (sp->defined & ~N_EXT) == N_SETB)
  1921. +         {
  1922. +           this_hunk = number_of_bss_hunk;
  1923. +         }
  1924. +       else    
  1925. +         fatal_with_file ("external symbol with unknown type $%x in ", entry, sp->defined);
  1926. + #endif
  1927.       }
  1928.         else switch (RELOC_TYPE(p))
  1929. ***************
  1930. *** 4833,4847 ****
  1931.       case N_TEXT:
  1932.       case N_TEXT | N_EXT:
  1933. !       relocation = text_relocation;
  1934.         break;
  1935.   
  1936.       case N_DATA:
  1937.       case N_DATA | N_EXT:
  1938. !       relocation = data_relocation;
  1939.         break;
  1940.   
  1941.       case N_BSS:
  1942.       case N_BSS | N_EXT:
  1943. !       relocation = bss_relocation;
  1944.         break;
  1945.   
  1946. --- 5491,5531 ----
  1947.       case N_TEXT:
  1948.       case N_TEXT | N_EXT:
  1949. !       if (RELOC_BASEREL_P (p))
  1950. !         {
  1951. !           fprintf (stderr, "symn = $%x, extern = %d, addr = $%lx.\n",
  1952. !                      p->r_symbolnum, p->r_extern, p->r_address);
  1953. !           fatal_with_file ("base relative text relocation in ", entry);
  1954. !         }
  1955. !       else
  1956. !         relocation = text_relocation;
  1957. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1958. !       this_hunk = number_of_code_hunk;
  1959. ! #endif
  1960.         break;
  1961.   
  1962.       case N_DATA:
  1963.       case N_DATA | N_EXT:
  1964. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1965. !       if (RELOC_BASEREL_P (p))
  1966. !         relocation = entry->data_start_address;
  1967. !       else
  1968. ! #endif
  1969. !         relocation = data_relocation;
  1970. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1971. !       this_hunk = number_of_data_hunk;
  1972. ! #endif
  1973.         break;
  1974.   
  1975.       case N_BSS:
  1976.       case N_BSS | N_EXT:
  1977. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1978. !       if (RELOC_BASEREL_P (p))
  1979. !         relocation = entry->bss_start_address - entry->data_size;
  1980. !       else
  1981. ! #endif
  1982. !         relocation = bss_relocation;
  1983. ! #ifdef HUNK_INSTEAD_OF_A_OUT
  1984. !       this_hunk = number_of_bss_hunk;
  1985. ! #endif
  1986.         break;
  1987.   
  1988. ***************
  1989. *** 4855,4861 ****
  1990. --- 5539,5570 ----
  1991.       }
  1992.   
  1993. + #ifdef HUNK_INSTEAD_OF_A_OUT
  1994. +       /* in this case, ONLY relocate those pc-relative 32bit jumps, that
  1995. +        * gas generates, since they are position independent, this gives
  1996. +        * a HUGE.. 'if' inside of '#ifdef' oh well... */
  1997. +       if (RELOC_PCREL_P(p) || RELOC_BASEREL_P(p) || ext_abs) {
  1998. +       
  1999. +       /* VERY BIG KLUDGE AHEAD! Since this amiga hunk format is really
  2000. +        * limited, 8bit and 16bit references are always defined to be
  2001. +        * pc-relative (according to the AmigaDOS RM 2nd ed). BUT if such
  2002. +        * a symbol is resolved by an absolute symbol then it's not considered
  2003. +        * to be pc-relative any more. This is nowhere documented, but you
  2004. +        * couldn't get
  2005. +        *   jsr _LVOOpen(a6)
  2006. +        * to work if you wouldn't do it this way. */
  2007. +        if (ext_abs) RELOC_PCREL_P(p) = 0;
  2008. +       
  2009. + #endif
  2010.         if (RELOC_PCREL_P(p))
  2011.       relocation -= pc_relocation;
  2012.   
  2013. +       /* if base relative, subtract 64k/2, so we get a larger range */
  2014. +       if (RELOC_BASEREL_P(p))
  2015. +     {
  2016. +       if (! databss_together)
  2017. +         fatal_with_file ("Reloc is base relative. Specify -databss-together in ", entry);
  2018. +       relocation -= 0x7ffe;
  2019. +     }
  2020. + 
  2021.   #ifdef RELOC_ADD_EXTRA
  2022.         relocation += RELOC_ADD_EXTRA(p);
  2023. ***************
  2024. *** 4896,4900 ****
  2025.         relocation <<= RELOC_TARGET_BITPOS(p);
  2026.         mask <<= RELOC_TARGET_BITPOS(p);
  2027. - 
  2028.         switch (RELOC_TARGET_SIZE(p))
  2029.       {
  2030. --- 5605,5608 ----
  2031. ***************
  2032. *** 4904,4907 ****
  2033. --- 5612,5618 ----
  2034.         else if (RELOC_MEMORY_ADD_P(p))
  2035.           relocation += mask & *(char *) (data + addr);
  2036. +       if (relocation < -128 || relocation > 127)
  2037. +         fatal_with_file ("Byte reloc overflow in ", entry);
  2038. + 
  2039.         *(char *) (data + addr) &= ~mask;
  2040.         *(char *) (data + addr) |= relocation;
  2041. ***************
  2042. *** 4909,4919 ****
  2043.   
  2044.       case 1:
  2045. !       if (RELOC_MEMORY_SUB_P(p))
  2046.           relocation -= mask & *(short *) (data + addr);
  2047.         else if (RELOC_MEMORY_ADD_P(p))
  2048.           relocation += mask & *(short *) (data + addr);
  2049.         *(short *) (data + addr) &= ~mask;
  2050.         *(short *) (data + addr) |= relocation;
  2051.         break;
  2052.   
  2053.       case 2:
  2054. --- 5620,5648 ----
  2055.   
  2056.       case 1:
  2057. !       {
  2058. !       int r=relocation;
  2059. ! 
  2060. !       if (RELOC_MEMORY_SUB_P(p))
  2061.           relocation -= mask & *(short *) (data + addr);
  2062.         else if (RELOC_MEMORY_ADD_P(p))
  2063.           relocation += mask & *(short *) (data + addr);
  2064. + 
  2065. +       if (relocation < -32768 || relocation > 32767)
  2066. +         {
  2067. +           fprintf (stderr, "relocation = $%lx, bsr = %d, pcr = %d, r= $%lx\n",
  2068. +                      relocation, RELOC_BASEREL_P(p), RELOC_PCREL_P (p), r);
  2069. +           fprintf (stderr, "textr = $%x, datar = $%x, bssr = $%x\n",
  2070. +                      text_relocation, data_relocation, bss_relocation);
  2071. +           fprintf (stderr, "symn = $%x, extern = %d, addr = $%lx.\n",
  2072. +                      p->r_symbolnum, p->r_extern, p->r_address);
  2073. +           fprintf (stderr, "data_size = %d, bss_size = %d.\n",
  2074. +                data_size, bss_size);
  2075. +           fatal_with_file ("Word reloc overflow in ", entry);
  2076. +         }
  2077. + 
  2078.         *(short *) (data + addr) &= ~mask;
  2079.         *(short *) (data + addr) |= relocation;
  2080.         break;
  2081. +       }
  2082.   
  2083.       case 2:
  2084. ***************
  2085. *** 4938,4941 ****
  2086. --- 5667,5671 ----
  2087.         else if (RELOC_MEMORY_ADD_P(p))
  2088.           relocation += mask & *(long *) (data + addr);
  2089. + 
  2090.         *(long *) (data + addr) &= ~mask;
  2091.         *(long *) (data + addr) |= relocation;
  2092. ***************
  2093. *** 4946,4952 ****
  2094.         fatal_with_file ("Unimplemented relocation field length in ", entry);
  2095.       }
  2096.       }
  2097.   }
  2098. ! 
  2099.   /* For OUTPUT_RELOCATABLE only: write out the relocation,
  2100.      relocating the addresses-to-be-relocated.  */
  2101. --- 5676,5713 ----
  2102.         fatal_with_file ("Unimplemented relocation field length in ", entry);
  2103.       }
  2104. + 
  2105. + #ifdef HUNK_INSTEAD_OF_A_OUT
  2106. +     /* now finish this huge 'if' .. */
  2107. +     }
  2108. +     else
  2109. +       {
  2110. +         /* this only deals with 32bit relocs, the Amiga-loader
  2111. +          * doesn't support 1 or 2 byte relocs, they are only defined
  2112. +          * inside program-units (commonly known as object-files:-)) */
  2113. + 
  2114. +         if (RELOC_TARGET_SIZE(p) != 2)
  2115. +           fatal_with_file ("unsupported reloc-size in ", entry);
  2116. + 
  2117. + /* Phil.B: 06-Apr-94 same kludge as above for host with stricter alignment
  2118. +    than the taget. */
  2119. + #ifdef CROSS_LINKER
  2120. +       {
  2121. +         /* Thing to relocate.  */
  2122. +         long thing;
  2123. +         bcopy (data + addr, &thing, sizeof (thing));
  2124. +         thing += relocation;
  2125. +         bcopy (&thing, data + addr, sizeof (thing));
  2126. +       }
  2127. + #else
  2128. +         *(long *) (data + addr) += relocation;
  2129. + #endif /* CROSS_LINKER */
  2130. + 
  2131. +         addr += pc_relocation;
  2132. +             add_to_reloc_hunk(this_hunk, addr);
  2133. +       }
  2134. + #endif
  2135.       }
  2136.   }
  2137. ! 
  2138.   /* For OUTPUT_RELOCATABLE only: write out the relocation,
  2139.      relocating the addresses-to-be-relocated.  */
  2140. ***************
  2141. *** 4996,5000 ****
  2142.     /* Write out the relocations of all files, remembered from copy_text.  */
  2143.   
  2144. !   lseek (outdesc, output_trel_offset, 0);
  2145.     each_full_file (coptxtrel, 0);
  2146.   
  2147. --- 5757,5761 ----
  2148.     /* Write out the relocations of all files, remembered from copy_text.  */
  2149.   
  2150. !   fseek (outstream, output_trel_offset, 0);
  2151.     each_full_file (coptxtrel, 0);
  2152.   
  2153. ***************
  2154. *** 5002,5006 ****
  2155.       fprintf (stderr, "\nWriting data relocation:\n\n");
  2156.   
  2157. !   lseek (outdesc, output_drel_offset, 0);
  2158.     each_full_file (copdatrel, 0);
  2159.   
  2160. --- 5763,5767 ----
  2161.       fprintf (stderr, "\nWriting data relocation:\n\n");
  2162.   
  2163. !   fseek (outstream, output_drel_offset, 0);
  2164.     each_full_file (copdatrel, 0);
  2165.   
  2166. ***************
  2167. *** 5077,5081 ****
  2168.   #endif
  2169.   
  2170. !   mywrite (entry->textrel, 1, entry->text_reloc_size, outdesc);
  2171.   }
  2172.   
  2173. --- 5838,5842 ----
  2174.   #endif
  2175.   
  2176. !   mywrite (entry->textrel, 1, entry->text_reloc_size, outstream);
  2177.   }
  2178.   
  2179. ***************
  2180. *** 5156,5162 ****
  2181.   #endif
  2182.   
  2183. !   mywrite (entry->datarel, 1, entry->data_reloc_size, outdesc);
  2184.   }
  2185. ! 
  2186.   void write_file_syms ();
  2187.   void write_string_table ();
  2188. --- 5917,5923 ----
  2189.   #endif
  2190.   
  2191. !   mywrite (entry->datarel, 1, entry->data_reloc_size, outstream);
  2192.   }
  2193. ! 
  2194.   void write_file_syms ();
  2195.   void write_string_table ();
  2196. ***************
  2197. *** 5193,5198 ****
  2198.   }
  2199.   
  2200. - FILE *outstream = (FILE *) 0;
  2201. - 
  2202.   /* Write the contents of `strtab_vector' into the string table.
  2203.      This is done once for each file's local&debugger symbols
  2204. --- 5954,5957 ----
  2205. ***************
  2206. *** 5204,5211 ****
  2207.     register int i;
  2208.   
  2209. !   lseek (outdesc, output_strs_offset + output_strs_size, 0);
  2210.   
  2211.     if (!outstream)
  2212.       outstream = fdopen (outdesc, "w");
  2213.   
  2214.     for (i = 0; i < strtab_index; i++)
  2215. --- 5963,5972 ----
  2216.     register int i;
  2217.   
  2218. !   fseek (outstream, output_strs_offset + output_strs_size, 0);
  2219.   
  2220. + #if 0
  2221.     if (!outstream)
  2222.       outstream = fdopen (outdesc, "w");
  2223. + #endif
  2224.   
  2225.     for (i = 0; i < strtab_index; i++)
  2226. ***************
  2227. *** 5221,5225 ****
  2228.       perror_name (output_filename);
  2229.   }
  2230. ! 
  2231.   /* Write the symbol table and string table of the output file.  */
  2232.   
  2233. --- 5982,5986 ----
  2234.       perror_name (output_filename);
  2235.   }
  2236. ! 
  2237.   /* Write the symbol table and string table of the output file.  */
  2238.   
  2239. ***************
  2240. *** 5249,5252 ****
  2241. --- 6010,6019 ----
  2242.     register struct nlist *bufp = buf;
  2243.   
  2244. + #ifdef HUNK_INSTEAD_OF_A_OUT
  2245. +   /* this enables us to output "regular" amiga symbols without
  2246. +    * the BSD-like debug-hunk */
  2247. +   if (number_of_debug_hunk == -1) return;
  2248. + #endif
  2249. + 
  2250.     /* Size of string table includes the bytes that store the size.  */
  2251.     strtab_size = sizeof strtab_size;
  2252. ***************
  2253. *** 5371,5376 ****
  2254.     /* Output the buffer full of `struct nlist's.  */
  2255.   
  2256. !   lseek (outdesc, output_syms_offset + output_syms_size, 0);
  2257. !   mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  2258.     output_syms_size += sizeof (struct nlist) * (bufp - buf);
  2259.   
  2260. --- 6138,6143 ----
  2261.     /* Output the buffer full of `struct nlist's.  */
  2262.   
  2263. !   fseek (outstream, output_syms_offset + output_syms_size, 0);
  2264. !   mywrite (buf, sizeof (struct nlist), bufp - buf, outstream);
  2265.     output_syms_size += sizeof (struct nlist) * (bufp - buf);
  2266.   
  2267. ***************
  2268. *** 5381,5386 ****
  2269.        first word of the string table.  */
  2270.   
  2271. !   lseek (outdesc, output_strs_offset, 0);
  2272. !   mywrite (&strtab_size, sizeof (int), 1, outdesc);
  2273.   
  2274.     /* Write the strings for the global symbols.  */
  2275. --- 6148,6153 ----
  2276.        first word of the string table.  */
  2277.   
  2278. !   fseek (outstream, output_strs_offset, 0);
  2279. !   mywrite (&strtab_size, sizeof (int), 1, outstream);
  2280.   
  2281.     /* Write the strings for the global symbols.  */
  2282. ***************
  2283. *** 5388,5392 ****
  2284.     write_string_table ();
  2285.   }
  2286. ! 
  2287.   /* Write the local and debugger symbols of file ENTRY.
  2288.      Increment *SYMS_WRITTEN_ADDR for each symbol that is written.  */
  2289. --- 6155,6159 ----
  2290.     write_string_table ();
  2291.   }
  2292. ! 
  2293.   /* Write the local and debugger symbols of file ENTRY.
  2294.      Increment *SYMS_WRITTEN_ADDR for each symbol that is written.  */
  2295. ***************
  2296. *** 5490,5495 ****
  2297.     /* All the symbols are now in BUF; write them.  */
  2298.   
  2299. !   lseek (outdesc, output_syms_offset + output_syms_size, 0);
  2300. !   mywrite (buf, sizeof (struct nlist), bufp - buf, outdesc);
  2301.     output_syms_size += sizeof (struct nlist) * (bufp - buf);
  2302.   
  2303. --- 6257,6262 ----
  2304.     /* All the symbols are now in BUF; write them.  */
  2305.   
  2306. !   fseek (outstream, output_syms_offset + output_syms_size, 0);
  2307. !   mywrite (buf, sizeof (struct nlist), bufp - buf, outstream);
  2308.     output_syms_size += sizeof (struct nlist) * (bufp - buf);
  2309.   
  2310. ***************
  2311. *** 5500,5504 ****
  2312.     entry->strings = 0;        /* Since it will dissapear anyway.  */
  2313.   }
  2314. ! 
  2315.   /* Copy any GDB symbol segments from the input files to the output file.
  2316.      The contents of the symbol segment is copied without change
  2317. --- 6267,6271 ----
  2318.     entry->strings = 0;        /* Since it will dissapear anyway.  */
  2319.   }
  2320. ! 
  2321.   /* Copy any GDB symbol segments from the input files to the output file.
  2322.      The contents of the symbol segment is copied without change
  2323. ***************
  2324. *** 5510,5514 ****
  2325.   write_symsegs ()
  2326.   {
  2327. !   lseek (outdesc, output_symseg_offset, 0);
  2328.     each_file (write_file_symseg, 0);
  2329.   }
  2330. --- 6277,6281 ----
  2331.   write_symsegs ()
  2332.   {
  2333. !   fseek (outstream, output_symseg_offset, 0);
  2334.     each_file (write_file_symseg, 0);
  2335.   }
  2336. ***************
  2337. *** 5545,5549 ****
  2338.     /* Write the modified root into the output file.  */
  2339.   
  2340. !   mywrite (&root, sizeof root, 1, outdesc);
  2341.   
  2342.     /* Copy the rest of the symbol segment unchanged.  */
  2343. --- 6312,6316 ----
  2344.     /* Write the modified root into the output file.  */
  2345.   
  2346. !   mywrite (&root, sizeof root, 1, outstream);
  2347.   
  2348.     /* Copy the rest of the symbol segment unchanged.  */
  2349. ***************
  2350. *** 5558,5567 ****
  2351.       fatal_with_file ("premature end of file in symbol segment of ", entry);
  2352.         total -= len;
  2353. !       mywrite (buffer, len, 1, outdesc);
  2354.       }
  2355.   
  2356.     file_close ();
  2357.   }
  2358. ! 
  2359.   /* Define a special symbol (etext, edata, or end).  NAME is the
  2360.      name of the symbol, with a leading underscore (whether or not this
  2361. --- 6325,6334 ----
  2362.       fatal_with_file ("premature end of file in symbol segment of ", entry);
  2363.         total -= len;
  2364. !       mywrite (buffer, len, 1, outstream);
  2365.       }
  2366.   
  2367.     file_close ();
  2368.   }
  2369. ! 
  2370.   /* Define a special symbol (etext, edata, or end).  NAME is the
  2371.      name of the symbol, with a leading underscore (whether or not this
  2372. ***************
  2373. *** 5617,5620 ****
  2374. --- 6384,6413 ----
  2375.     symbol_define ("__end", N_BSS | N_EXT, &end_symbol_alt);
  2376.   
  2377. + #ifdef amigados
  2378. +   if (output_datadata_relocs)
  2379. +     symbol_define ("___datadata_relocs", N_TEXT | N_EXT, &datadata_reloc_symbol);
  2380. + 
  2381. +   symbol_define ("__sdata", N_DATA | N_EXT, &sdata_symbol);
  2382. +   symbol_define ("___text_size", N_ABS | N_EXT, &text_size_symbol);
  2383. +   symbol_define ("___data_size", N_ABS | N_EXT, &data_size_symbol);
  2384. +   symbol_define ("___bss_size", N_ABS | N_EXT, &bss_size_symbol);
  2385. +   {
  2386. +     symbol *a_symbol;
  2387. +     symbol_define ("___machtype", N_ABS | N_EXT, &a_symbol);
  2388. +     if (a_symbol)
  2389. +       a_symbol->value = amiga_machtype;
  2390. +       
  2391. +     symbol_define ("___databss_together", N_ABS | N_EXT, &a_symbol);
  2392. +     if (a_symbol)
  2393. +       a_symbol->value = databss_together;
  2394. +       
  2395. +     if (databss_together)
  2396. +       {
  2397. +         symbol_define ("___a4_init", N_DATA | N_EXT, &a_symbol);
  2398. +         if (a_symbol)
  2399. +           a_symbol->value = data_start + 0x7ffe;
  2400. +       }
  2401. +   }
  2402. + #endif
  2403.   #ifdef sun
  2404.     {
  2405. ***************
  2406. *** 5659,5663 ****
  2407.     return k;
  2408.   }
  2409. ! 
  2410.   /* Get the symbol table entry for the global symbol named KEY.
  2411.      Create one if there is none.  */
  2412. --- 6452,6456 ----
  2413.     return k;
  2414.   }
  2415. ! 
  2416.   /* Get the symbol table entry for the global symbol named KEY.
  2417.      Create one if there is none.  */
  2418. ***************
  2419. *** 5726,5730 ****
  2420.     return 0;
  2421.   }
  2422. ! 
  2423.   /* Report a usage error.
  2424.      Like fatal except prints a usage summary.  */
  2425. --- 6519,6523 ----
  2426.     return 0;
  2427.   }
  2428. ! 
  2429.   /* Report a usage error.
  2430.      Like fatal except prints a usage summary.  */
  2431. ***************
  2432. *** 5740,5743 ****
  2433. --- 6533,6546 ----
  2434.         fprintf (stderr, "\n");
  2435.       }
  2436. + #ifdef HUNK_INSTEAD_OF_A_OUT
  2437. +   fprintf (stderr, "\
  2438. + Usage: %s [-d] [-dc] [-dp] [-e symbol] [-l lib] [-n] [-noinhibit-exec]\n\
  2439. +        [-nostdlib] [-o file] [-r] [-s] [-t] [-u symbol] [-x] [-y symbol]\n\
  2440. +        [-z] [-A file] [-Bstatic] [-D size] [-L libdir] [-M] [-N]\n\
  2441. +        [-S] [-T[{text,data}] addr] [-V prefix] [-X] \n\
  2442. +        [{-a,-amiga-debug-hunk}] [{-f,-flavor} flavor] [file...]\n\
  2443. +        [-chip {c,d,b}] [-fast {c,d,b}] [-m,-shortdata]\n",
  2444. +        progname);
  2445. + #else
  2446.     fprintf (stderr, "\
  2447.   Usage: %s [-d] [-dc] [-dp] [-e symbol] [-l lib] [-n] [-noinhibit-exec]\n\
  2448. ***************
  2449. *** 5746,5749 ****
  2450. --- 6549,6553 ----
  2451.          [-S] [-T[{text,data}] addr] [-V prefix] [-X] [file...]\n",
  2452.          progname);
  2453. + #endif
  2454.     exit (1);
  2455.   }
  2456. ***************
  2457. *** 5766,5775 ****
  2458.   
  2459.   void
  2460. ! fatal_with_file (string, entry)
  2461.        char *string;
  2462.        struct file_entry *entry;
  2463.   {
  2464.     fprintf (stderr, "%s: ", progname);
  2465. !   fprintf (stderr, string);
  2466.     print_file_name (entry, stderr);
  2467.     fprintf (stderr, "\n");
  2468. --- 6570,6579 ----
  2469.   
  2470.   void
  2471. ! fatal_with_file (string, entry, arg)
  2472.        char *string;
  2473.        struct file_entry *entry;
  2474.   {
  2475.     fprintf (stderr, "%s: ", progname);
  2476. !   fprintf (stderr, string, arg);
  2477.     print_file_name (entry, stderr);
  2478.     fprintf (stderr, "\n");
  2479. ***************
  2480. *** 5785,5793 ****
  2481.   {
  2482.     extern int errno, sys_nerr;
  2483. -   extern char *sys_errlist[];
  2484.     char *s;
  2485.   
  2486.     if (errno < sys_nerr)
  2487. !     s = concat ("", sys_errlist[errno], " for %s");
  2488.     else
  2489.       s = "cannot open %s";
  2490. --- 6589,6596 ----
  2491.   {
  2492.     extern int errno, sys_nerr;
  2493.     char *s;
  2494.   
  2495.     if (errno < sys_nerr)
  2496. !     s = concat ("", strerror (errno), " for %s");
  2497.     else
  2498.       s = "cannot open %s";
  2499. ***************
  2500. *** 5803,5811 ****
  2501.   {
  2502.     extern int errno, sys_nerr;
  2503. -   extern char *sys_errlist[];
  2504.     char *s;
  2505.   
  2506.     if (errno < sys_nerr)
  2507. !     s = concat ("", sys_errlist[errno], " for ");
  2508.     else
  2509.       s = "cannot open ";
  2510. --- 6606,6613 ----
  2511.   {
  2512.     extern int errno, sys_nerr;
  2513.     char *s;
  2514.   
  2515.     if (errno < sys_nerr)
  2516. !     s = concat ("", strerror (errno), " for ");
  2517.     else
  2518.       s = "cannot open ";
  2519. ***************
  2520. *** 5825,5839 ****
  2521.   }
  2522.   
  2523. ! 
  2524.   /* Output COUNT*ELTSIZE bytes of data at BUF
  2525.      to the descriptor DESC.  */
  2526.   
  2527.   void
  2528. ! mywrite (buf, count, eltsize, desc)
  2529.        char *buf;
  2530.        int count;
  2531.        int eltsize;
  2532. !      int desc;
  2533.   {
  2534.     register int val;
  2535.     register int bytes = count * eltsize;
  2536. --- 6627,6642 ----
  2537.   }
  2538.   
  2539. ! 
  2540.   /* Output COUNT*ELTSIZE bytes of data at BUF
  2541.      to the descriptor DESC.  */
  2542.   
  2543.   void
  2544. ! mywrite (buf, count, eltsize, stream)
  2545.        char *buf;
  2546.        int count;
  2547.        int eltsize;
  2548. !      FILE *stream;
  2549.   {
  2550. + #if 0
  2551.     register int val;
  2552.     register int bytes = count * eltsize;
  2553. ***************
  2554. *** 5847,5859 ****
  2555.         bytes -= val;
  2556.       }
  2557.   }
  2558.   
  2559. ! /* Output PADDING zero-bytes to descriptor OUTDESC.
  2560.      PADDING may be negative; in that case, do nothing.  */
  2561.   
  2562.   void
  2563. ! padfile (padding, outdesc)
  2564.        int padding;
  2565. !      int outdesc;
  2566.   {
  2567.     register char *buf;
  2568. --- 6650,6665 ----
  2569.         bytes -= val;
  2570.       }
  2571. + #else
  2572. +   fwrite (buf, eltsize, count, stream);
  2573. + #endif
  2574.   }
  2575.   
  2576. ! /* Output PADDING zero-bytes to descriptor OUTSTREAM.
  2577.      PADDING may be negative; in that case, do nothing.  */
  2578.   
  2579.   void
  2580. ! padfile (padding, outstream)
  2581.        int padding;
  2582. !      FILE *outstream;
  2583.   {
  2584.     register char *buf;
  2585. ***************
  2586. *** 5863,5867 ****
  2587.     buf = (char *) alloca (padding);
  2588.     bzero (buf, padding);
  2589. !   mywrite (buf, padding, 1, outdesc);
  2590.   }
  2591.   
  2592. --- 6669,6673 ----
  2593.     buf = (char *) alloca (padding);
  2594.     bzero (buf, padding);
  2595. !   mywrite (buf, padding, 1, outstream);
  2596.   }
  2597.   
  2598. ***************
  2599. *** 5904,5909 ****
  2600.        int size;
  2601.   {
  2602.     register char *result = malloc (size);
  2603. !   if (!result)
  2604.       fatal ("virtual memory exhausted", 0);
  2605.     return result;
  2606. --- 6710,6716 ----
  2607.        int size;
  2608.   {
  2609. +   extern char *malloc();
  2610.     register char *result = malloc (size);
  2611. !   if (!result && size)
  2612.       fatal ("virtual memory exhausted", 0);
  2613.     return result;
  2614. ***************
  2615. *** 5917,5926 ****
  2616.        int size;
  2617.   {
  2618. !   register char *result = realloc (ptr, size);
  2619.     if (!result)
  2620.       fatal ("virtual memory exhausted", 0);
  2621.     return result;
  2622.   }
  2623. ! 
  2624.   #ifdef USG
  2625.   
  2626. --- 6724,6734 ----
  2627.        int size;
  2628.   {
  2629. !   extern char *malloc(), *realloc();
  2630. !   register char *result = ptr ? realloc (ptr, size) : malloc (size);
  2631.     if (!result)
  2632.       fatal ("virtual memory exhausted", 0);
  2633.     return result;
  2634.   }
  2635. ! 
  2636.   #ifdef USG
  2637.   
  2638. ***************
  2639. *** 5953,5954 ****
  2640. --- 6761,7409 ----
  2641.   }
  2642.   #endif
  2643. + 
  2644. + #ifdef HUNK_INSTEAD_OF_A_OUT
  2645. + /* the whole rest of the file is used for managment of hunks and subhunks.. */
  2646. + 
  2647. + /* this is the amiga-equivalent of struct exec */
  2648. + struct simple_hunk_header {
  2649. +   long    id,    /* this will be 0x3f3 */
  2650. +     zero,
  2651. +     table_size,
  2652. +     first_hunk,
  2653. +     last_hunk,
  2654. +     sizes[4];   /* there can be at most a code,data,bss & debug hunk */
  2655. + };
  2656. + 
  2657. + /* this writes out a hunk header, depending on the information collected
  2658. +  * so far, it will only create hunks, that really exist, so if your data-
  2659. +  * size is zero, you won't get a data-hunk at all. */
  2660. + 
  2661. + void
  2662. + write_hunk_header(outfd)
  2663. +     int outfd;
  2664. + {
  2665. +   struct simple_hunk_header sh;
  2666. +   int this_hunk, header_size;
  2667. + 
  2668. +   sh.id = 0x3f3;    /* HUNK_HEADER */
  2669. +   sh.zero = 0;
  2670. +   sh.table_size = current_hunk;
  2671. +   sh.first_hunk = 0;
  2672. +   sh.last_hunk  = current_hunk - 1;
  2673. + 
  2674. +   this_hunk = 0;
  2675. +   if (number_of_code_hunk != -1)
  2676. +      sh.sizes[this_hunk++] = code_mem_type|LONGSIZE(text_size);
  2677. + 
  2678. +   if (number_of_data_hunk != -1)
  2679. +   {
  2680. +      int size = LONGSIZE(data_size);
  2681. +      if (databss_together)
  2682. +      {
  2683. +        if (long_data_hunk || !output_datadata_relocs)
  2684. +          size=LONGSIZE(data_size+bss_size);
  2685. +        if (data_mem_type == 0)
  2686. +          data_mem_type=bss_mem_type;
  2687. +      }
  2688. +      sh.sizes[this_hunk++] = data_mem_type|size;
  2689. +   }
  2690. + 
  2691. +   if (!databss_together && number_of_bss_hunk  != -1)
  2692. +      sh.sizes[this_hunk++] = bss_mem_type|LONGSIZE(bss_size);
  2693. + 
  2694. +   if (number_of_debug_hunk != -1)
  2695. +      sh.sizes[this_hunk++] = 0;  /* to be filled in later */
  2696. + 
  2697. +   header_size = sizeof(sh) - (4-this_hunk)*sizeof(long);
  2698. +   mywrite(&sh, 1, header_size, outfd);
  2699. + }
  2700. + 
  2701. + /* if we really write out a debug hunk, this fills in the remaining
  2702. +  * spots, that are known only at the end of load-file output */
  2703. + 
  2704. + void
  2705. + conditionally_rewrite_headers ()
  2706. + {
  2707. +   long size_of_debug_hunk,
  2708. +        end_hunk = 0x3f2,
  2709. +        eof;
  2710. + 
  2711. +   /* if we don't want a debug hunk, just return */
  2712. +   if (number_of_debug_hunk == -1)  return;
  2713. + 
  2714. +   /* while we're at it, since we started the debug-hunk, lets finish it
  2715. +    * now. */
  2716. +   fseek (outstream, 0L, 2);
  2717. +   eof = ftell (outstream);
  2718. +   dh.strs = eof - offset_of_debug_hunk - sizeof(dh) - dh.syms;
  2719. +   /* just to be sure, we HAVE to pad to a long-boundery */
  2720. +   if (eof & 3)
  2721. +     {
  2722. +       long zero = 0;
  2723. + 
  2724. +       mywrite(&zero, 4 - (eof & 3), 1, outstream);
  2725. +       eof = (eof + 3) & ~3;
  2726. +     }
  2727. + 
  2728. +   mywrite(&end_hunk, sizeof(long), 1, outstream);
  2729. + 
  2730. +   /* ok, so calculate the size of the debug hunk. This is the 
  2731. +    * size of the debug_header plus the symbol and string tables,
  2732. +    * but it doesn't include the 2 longs, that identify the hunk and
  2733. +    * its length, whence the "- 2*sizeof(long)" */
  2734. +   size_of_debug_hunk = eof - offset_of_debug_hunk - 2*sizeof(long);
  2735. +   /* we actually need the size in longs.. */
  2736. +   size_of_debug_hunk = LONGSIZE(size_of_debug_hunk);
  2737. + 
  2738. +   /* now first patch the debug-hunk itself, afterwards the load-file header */
  2739. +   fseek (outstream, offset_of_debug_hunk, 0);
  2740. +   dh.len = size_of_debug_hunk;
  2741. +   mywrite(&dh, sizeof dh, 1, outstream);
  2742. + 
  2743. +   /* now the main header, this involves calculating, at which offset we
  2744. +    * find the index for the debug hunk */   
  2745. +   fseek (outstream, (5 + number_of_debug_hunk)*sizeof(long), 0);
  2746. +   mywrite(&size_of_debug_hunk, sizeof(long), 1, outstream);
  2747. +   fseek (outstream, 0L, 2);
  2748. +   /* that's it! */
  2749. + }
  2750. + 
  2751. + /* this is the only information that we can store in a regular amiga
  2752. +  * symbol, just its value, nothing further, that's why I added the 
  2753. +  * debug-hunk-feature */
  2754. + 
  2755. + typedef struct {
  2756. +   char *sym_name;
  2757. +   long  sym_offset;
  2758. + } simple_symbol;
  2759. + 
  2760. + /* we'll only define symbols after at most 3 hunks, ie. the code, data
  2761. +  * and bss hunk, but not after the debug hunk, whence the index 3 */
  2762. + 
  2763. + simple_symbol *hunk_sym_tab[3];
  2764. + int hunk_sym_tab_size[3], hunk_sym_tab_index[3];
  2765. + 
  2766. + void
  2767. + init_symbol_hunks()
  2768. + {
  2769. +   int i;
  2770. + 
  2771. +   if (trace_files) fprintf(stderr, "init_symbol_hunks()\n");
  2772. + 
  2773. +   for (i = 0; i < 3; i++)
  2774. +     {
  2775. +        hunk_sym_tab[i] = 
  2776. +          (simple_symbol *) xmalloc((hunk_sym_tab_size[i] = 10) * 
  2777. +        sizeof(simple_symbol));
  2778. +        hunk_sym_tab_index[i] = 0;
  2779. +     }
  2780. + }
  2781. + 
  2782. + /* this should go into libc, well, it wasn't there, so... */
  2783. + 
  2784. + char *
  2785. + strsave(str)
  2786. +     char *str;
  2787. + {
  2788. +   char *cp;
  2789. +   int len = strlen(str);
  2790. +   if (len)
  2791. +     {
  2792. +       cp = xmalloc(len+1);
  2793. +       strcpy(cp, str);
  2794. +     }
  2795. +   else
  2796. +     cp = NULL;
  2797. +   return cp;
  2798. + }
  2799. + 
  2800. + void
  2801. + add_to_symbol_hunk(hunk_num, name, offset)
  2802. +     int hunk_num;
  2803. +     char *name;
  2804. +     long offset;
  2805. + {
  2806. +    if (hunk_num == -1) return;
  2807. +    if (hunk_num >= 3) fatal ("invalid hunk_number: %d\n", hunk_num);
  2808. + 
  2809. +    /* no checks for duplicate symbols. Since it is legitimate to have
  2810. +     * symbols with the same name, we can't strip them.. just make 
  2811. +     * sure not to call this function multiple times with the same
  2812. +     * symbol, since it won't be detected, and you'll get several
  2813. +     * labels for the same offset...
  2814. +     */
  2815. +     
  2816. +    if (trace_files) fprintf(stderr, "add_to_symbol_hunk(%d, %s, %d)\n",
  2817. +                 hunk_num, name, offset);
  2818. + 
  2819. +    hunk_sym_tab[hunk_num][hunk_sym_tab_index[hunk_num]].sym_offset = offset;
  2820. +    hunk_sym_tab[hunk_num][hunk_sym_tab_index[hunk_num]++].sym_name = 
  2821. +      strsave(name);
  2822. + 
  2823. +    if (hunk_sym_tab_index[hunk_num] == hunk_sym_tab_size[hunk_num])
  2824. +     hunk_sym_tab[hunk_num] = (simple_symbol *)
  2825. +       xrealloc(hunk_sym_tab[hunk_num],
  2826. +             (hunk_sym_tab_size[hunk_num] <<= 1) * 
  2827. +               sizeof(simple_symbol));
  2828. + }
  2829. + 
  2830. + int
  2831. + compare_simple_symbols(l1, l2)
  2832. +     simple_symbol *l1, *l2;
  2833. + {
  2834. +   return l1->sym_offset - l2->sym_offset;
  2835. + }
  2836. + 
  2837. + /* this writes the symbol subhunk #hunk_num, you call this just after
  2838. +  * you created your {code,data,bss}-hunk */
  2839. + 
  2840. + void
  2841. + write_symbol_hunk(hunk_num)
  2842. +     int hunk_num;
  2843. + {
  2844. +   int i, j;
  2845. +   simple_symbol *tab;
  2846. +   long size, index;
  2847. + 
  2848. +   if (hunk_num == -1) return;
  2849. +   if (hunk_num >= 3) fatal ("invalid hunk_number: %d\n", hunk_num);
  2850. +   
  2851. +   tab   = hunk_sym_tab[hunk_num];
  2852. +   size  = hunk_sym_tab_size[hunk_num];
  2853. +   index = hunk_sym_tab_index[hunk_num];
  2854. +    
  2855. +   /* kind of abused as general debug-flag:-) */
  2856. +   if (trace_files) fprintf(stderr, 
  2857. +                 "wsh: hnum=%d,size=%d,index=%d\n",
  2858. +                hunk_num,size,index);
  2859. +    
  2860. +   if (index > 0)
  2861. +     {
  2862. +       qsort(tab, index, sizeof(simple_symbol), compare_simple_symbols);
  2863. + 
  2864. +       j = 0x3f0; /* HUNK_SYMBOL */
  2865. +       mywrite(&j, 1, sizeof(long), outstream);
  2866. +    
  2867. +       for (i = 0; i < index; i++)
  2868. +         {
  2869. +        register simple_symbol *ss = tab+i;
  2870. +        int len = strlen (ss->sym_name);
  2871. + 
  2872. +        j = LONGSIZE (len);
  2873. +        mywrite(&j, 1, sizeof(long), outstream);
  2874. + 
  2875. +        mywrite(ss->sym_name, 1, len, outstream);
  2876. +        if (len < 4*j)
  2877. +          padfile (4*j - len, outstream);
  2878. + 
  2879. +        mywrite(&(ss->sym_offset), 1, sizeof(long), outstream);
  2880. +     }
  2881. + 
  2882. +       j = 0;
  2883. +       mywrite(&j, 1, sizeof(long), outstream);
  2884. +     }
  2885. + }
  2886. + 
  2887. + /* now follow the quite similar routines for dealing with
  2888. +  * reloc-subhunks, the difference to the symbol-subhunks is, that reloc
  2889. +  * subhunks can be output only after the {code,data}-Hunks, AND there
  2890. +  * can be more than one after each of them */
  2891. + 
  2892. + long *hunk_rel_tab[3], hunk_rel_tab_size[3], hunk_rel_tab_index[3];
  2893. + 
  2894. + void
  2895. + init_reloc_hunk()
  2896. + {
  2897. +   int i;
  2898. + 
  2899. +   if (trace_files) fprintf(stderr, "init_reloc_hunk()\n");
  2900. + 
  2901. +   for (i = 0; i < 3; i++)
  2902. +     {
  2903. +        hunk_rel_tab[i] = 
  2904. +          (long *) xmalloc((hunk_rel_tab_size[i] = 10) * sizeof(long));
  2905. +        hunk_rel_tab_index[i] = 0;
  2906. +     }
  2907. + }
  2908. + 
  2909. + void
  2910. + add_to_reloc_hunk(hunk_num, offset)
  2911. +     int hunk_num;
  2912. +     long offset;
  2913. + {
  2914. +    /* no checks for duplicate symbols, they will show up when we sort
  2915. +     * the table, and we will strip them off before writing out the table */
  2916. + 
  2917. +    if (trace_files) fprintf(stderr, "add_to_reloc_hunk(%d, %d)\n", hunk_num, offset);
  2918. + 
  2919. +    hunk_rel_tab[hunk_num][hunk_rel_tab_index[hunk_num]++] = offset;
  2920. + 
  2921. +    if (hunk_rel_tab_index[hunk_num] == hunk_rel_tab_size[hunk_num])
  2922. +     hunk_rel_tab[hunk_num] = (long *)
  2923. +       xrealloc(hunk_rel_tab[hunk_num],
  2924. +                    (hunk_rel_tab_size[hunk_num] <<= 1) * sizeof(long));
  2925. + }
  2926. + 
  2927. + int
  2928. + compare_longs(l1, l2)
  2929. +     long *l1, *l2;
  2930. + {
  2931. +   return *l1 - *l2;
  2932. + }
  2933. + 
  2934. + int
  2935. + compare_strings (s1p, s2p)
  2936. +     char **s1p;
  2937. +     char **s2p;
  2938. + {
  2939. +   return (strcmp (*s1p, *s2p));
  2940. + }
  2941. + 
  2942. + void
  2943. + write_reloc_hunk()
  2944. + {
  2945. +    int i, j;
  2946. +    long *tab, size, index;
  2947. +    /* only write a hunk-header & -end, if we really output some relocs */
  2948. +    int did_start_hunk = 0;
  2949. + 
  2950. +    for (i = 0; i < 3; i++)
  2951. +      {
  2952. +     tab   = hunk_rel_tab[i];
  2953. +     size  = hunk_rel_tab_size[i];
  2954. +     index = hunk_rel_tab_index[i];
  2955. + 
  2956. +     /* kind of abused as general debug-flag:-) */
  2957. +         if (trace_files) fprintf(stderr, 
  2958. +                  "wrh: i=%d,size=%d,index=%d\n",
  2959. +                  i,size,index);
  2960. + 
  2961. +         if (index > 0)
  2962. +       {
  2963. +         qsort(tab, index, sizeof(long), compare_longs);
  2964. + 
  2965. +         /* kick out duplicate symbols.. I don't know, what
  2966. +          * the loader would do, if it had to relocate the same
  2967. +          * address twice.. BTW: can this happen or can't it???? */
  2968. +         for (j = 0; j < index-1; )
  2969. +           {
  2970. +         if (tab[j] == tab[j+1])
  2971. +           bcopy(tab+j+1, tab+j, ((index--)-j-1)*sizeof(long));
  2972. +         else
  2973. +           j++;
  2974. +           }
  2975. + 
  2976. +         if (!did_start_hunk++)
  2977. +           {
  2978. +         j = 0x3ec; /* HUNK_RELOC32 */
  2979. +         mywrite(&j, 1, sizeof(long), outstream);
  2980. +           }
  2981. + 
  2982. +         mywrite(&index, 1, sizeof(long), outstream);
  2983. +         mywrite(&i, 1, sizeof(long), outstream);
  2984. +         mywrite(tab, 1, index*sizeof(long), outstream);
  2985. +         hunk_rel_tab_index[i] = index;
  2986. +       }
  2987. +      }
  2988. +    if (did_start_hunk)
  2989. +      {
  2990. +     j = 0;
  2991. +        mywrite(&j, 1, sizeof(long), outstream);
  2992. +      }
  2993. + }
  2994. + 
  2995. + 
  2996. + void
  2997. + write_datadata_relocs ()
  2998. + {
  2999. +   int numdd, i, prev;
  3000. + 
  3001. +   prev = ftell (outstream);
  3002. +   fseek (outstream, datadata_relocs_offset, L_SET);
  3003. +   
  3004. +   numdd = hunk_rel_tab_index[number_of_data_hunk];
  3005. +   if (numdd > numdatadata_relocs)
  3006. +     fatal ("found more data-data relocs than estimated!\n", 0);
  3007. +   
  3008. +   mywrite (&numdd, 1, sizeof (long), outstream);
  3009. +   if (numdd)
  3010. +     mywrite (hunk_rel_tab[number_of_data_hunk], numdd, sizeof (long), outstream);
  3011. + 
  3012. +   fseek (outstream, prev, L_SET);
  3013. + }
  3014. + 
  3015. + 
  3016. + /* create the bss hunk if needed */
  3017. + 
  3018. + void
  3019. + write_bss()
  3020. + {
  3021. +   long bss_hunk[2];
  3022. +   if (!databss_together && bss_size)
  3023. +    {
  3024. +      bss_hunk[0] = 0x3eb;
  3025. +      bss_hunk[1] = LONGSIZE(bss_size);
  3026. +      mywrite(bss_hunk, 1, sizeof bss_hunk, outstream);
  3027. +      write_symbol_hunk(number_of_bss_hunk);
  3028. +      bss_hunk[0] = 0x3f2; /* HUNK_END */
  3029. +      mywrite(bss_hunk, 1, sizeof(long), outstream);
  3030. +    }
  3031. + }
  3032. + 
  3033. + /* this scans one object file for its symbols, and deposits them in 
  3034. +  * the symbol-hunk tables for later output */
  3035. + 
  3036. + void
  3037. + look_for_file_syms (entry)
  3038. +      struct file_entry *entry;
  3039. + {
  3040. +   register struct nlist *p = entry->symbols;
  3041. +   register struct nlist *end = p + entry->syms_size / sizeof (struct nlist);
  3042. + 
  3043. + #if 0
  3044. +   /* don't do this, it only confuses most amiga disassemblers.. */
  3045. + 
  3046. +   /* Generate a local symbol for the start of this file's text.  */
  3047. + 
  3048. +   if (discard_locals != DISCARD_ALL)
  3049. +     add_to_symbol_hunk(number_of_code_hunk, entry->local_sym_name, 
  3050. +        entry->text_start_address);
  3051. + #endif
  3052. + 
  3053. +   /* Read the file's string table.  */
  3054. + 
  3055. +   entry->strings = (char *) alloca (entry->strs_size);
  3056. +   read_entry_strings (file_open (entry), entry);
  3057. + 
  3058. +   for (; p < end; p++)
  3059. +     {
  3060. +       register unsigned char type = p->n_type;
  3061. +       register int write = 0;
  3062. +       int this_hunk;
  3063. +       char *cp;
  3064. + 
  3065. +       /* WRITE gets 1 for a non-global symbol that should be written.  */
  3066. + 
  3067. +       if (SET_ELEMENT_P (type))    /* This occurs even if global.  These */
  3068. +                 /* types of symbols are never written */
  3069. +                 /* globally, though they are stored */
  3070. +                 /* globally.  */
  3071. +         write = output_style == OUTPUT_RELOCATABLE;
  3072. +       else if (!(type & (N_STAB | N_EXT)))
  3073. +           /* ordinary local symbol */
  3074. +       write = ((discard_locals != DISCARD_ALL)
  3075. +            && !(discard_locals == DISCARD_L &&
  3076. +                (p->n_un.n_strx + entry->strings)[0] == LPREFIX)
  3077. +            && type != N_WARNING);
  3078. + 
  3079. +       else if (!(type & N_EXT))
  3080. +     /* debugger symbol */
  3081. +         write = (strip_symbols == STRIP_NONE);
  3082. + 
  3083. +       /* skip STAB symbols if present */
  3084. +       write = write && !(type & N_STAB);
  3085. + 
  3086. +       /* those weird types are NOT output in the normal symbols:-)) */
  3087. +       write = write && (type != N_ABS && type != (N_ABS|N_EXT));
  3088. + 
  3089. +       /* don't know where those symbols come from, they're well suited to
  3090. +        * crash enforcer, and they're not `real' symbols anyway.. */
  3091. +       if (p->n_un.n_strx > entry->strs_size) continue;
  3092. + 
  3093. +       /* symbols that end with a dot are only useful for gdb, 
  3094. +        * not for a normal amiga debugger (currently gcc_compiled. and
  3095. +        * gcc_compiled2.) so skip them in this section */
  3096. + 
  3097. +       /* check to see, whether this string ends with a dot */
  3098. +       if (write && p->n_un.n_strx)
  3099. +         {
  3100. +           cp = rindex (p->n_un.n_strx + entry->strings, '.');
  3101. + 
  3102. +       write = write && !(cp && !cp[1]);
  3103. +       
  3104. + #if 0
  3105. +       printf ("%s >%s<\n", write ? "adding" : "skipping", p->n_un.n_strx + entry->strings);
  3106. + #endif
  3107. +     }
  3108. + 
  3109. +       if (write)
  3110. +     {
  3111. +       if (p->n_un.n_strx)
  3112. +         {
  3113. +           switch (type & ~N_EXT)
  3114. +             {
  3115. +           case N_TEXT:
  3116. +             this_hunk = number_of_code_hunk;
  3117. +             break;
  3118. +           case N_SETV:
  3119. +           case N_DATA:
  3120. +             this_hunk = number_of_data_hunk;
  3121. +             break;
  3122. +           case N_UNDF:
  3123. +           case N_BSS:
  3124. +             this_hunk = number_of_bss_hunk;
  3125. +             break;
  3126. +           default:
  3127. +             error ("unknown type %d while trying to build lsymhunk", type);
  3128. +             goto skip1;
  3129. +             }
  3130. + 
  3131. +           add_to_symbol_hunk(this_hunk, p->n_un.n_strx + entry->strings,
  3132. +                  p->n_value);
  3133. + skip1:    ;
  3134. +             }
  3135. +     }
  3136. +     }
  3137. + }
  3138. + 
  3139. + /* scan all input files for symbols and store them in the symbolhunk tables */
  3140. + 
  3141. + void
  3142. + look_for_symbols()
  3143. + {
  3144. +   int this_hunk;
  3145. +   int i;
  3146. +   symbol *sp;
  3147. + 
  3148. +   if (strip_symbols == STRIP_ALL)
  3149. +     return;
  3150. + 
  3151. +   /* Write the local symbols defined by the various files.  */
  3152. + 
  3153. +   each_file (look_for_file_syms, 0);
  3154. +   file_close ();
  3155. + 
  3156. +   /* Scan the symbol hash table, bucket by bucket.  */
  3157. + 
  3158. +   for (i = 0; i < TABSIZE; i++)
  3159. +     for (sp = symtab[i]; sp; sp = sp->link)
  3160. +       {
  3161. +     struct nlist nl;
  3162. + 
  3163. +     /* Compute a `struct nlist' for the symbol.  */
  3164. + 
  3165. +     nl.n_value = 0;
  3166. + 
  3167. +     if (sp->defined || sp->referenced)
  3168. +       {
  3169. +         /* common condition needs to be before undefined condition */
  3170. +         /* because unallocated commons are set undefined in */
  3171. +         /* digest_symbols */
  3172. +         if (sp->defined > 1) /* defined with known type */
  3173. +           {
  3174. +         /* If the target of an indirect symbol has been
  3175. +            defined and we are outputting an executable,
  3176. +            resolve the indirection; it's no longer needed */
  3177. +         if (output_style != OUTPUT_RELOCATABLE
  3178. +             && ((sp->defined & ~N_EXT) == N_INDR)
  3179. +             && (((symbol *) sp->value)->defined > 1))
  3180. +           {
  3181. +             symbol *newsp = (symbol *) sp->value;
  3182. +             nl.n_type = newsp->defined;
  3183. +             nl.n_value = newsp->value;
  3184. +           }
  3185. +         else
  3186. +           {
  3187. +             nl.n_type = sp->defined;
  3188. +             if (sp->defined != (N_INDR | N_EXT))
  3189. +               nl.n_value = sp->value;
  3190. +             else
  3191. +               nl.n_value = 0;
  3192. +           }
  3193. +           }
  3194. +         else if (sp->max_common_size) /* defined as common but not allocated. */
  3195. +           {
  3196. +         /* happens only with -r and not -d */
  3197. +         /* write out a common definition */
  3198. +         nl.n_type = N_UNDF | N_EXT;
  3199. +         nl.n_value = sp->max_common_size;
  3200. +           }
  3201. +         else if (!sp->defined)          /* undefined -- legit only if -r */
  3202. +           {
  3203. +         nl.n_type = N_UNDF | N_EXT;
  3204. +         nl.n_value = 0;
  3205. +           }
  3206. +         else
  3207. +           fatal ("internal error: %s defined in mysterious way", sp->name);
  3208. + 
  3209. +         switch (nl.n_type & ~N_EXT)
  3210. +           {
  3211. +         case N_TEXT:
  3212. +           this_hunk = number_of_code_hunk;
  3213. +           break;
  3214. +         case N_SETV:
  3215. +         case N_DATA:
  3216. +           this_hunk = number_of_data_hunk;
  3217. +           break;
  3218. +         case N_UNDF:
  3219. +         case N_BSS:
  3220. +           this_hunk = number_of_bss_hunk;
  3221. +           break;
  3222. +         case N_ABS:
  3223. +           break;
  3224. +         default:
  3225. +           error ("unknown type %d while trying to build symhunk", nl.n_type);
  3226. +           goto skip2;
  3227. +           }
  3228. + 
  3229. +         /* sigh, there is no equivalent in the symbol section of a load
  3230. +          * file on the amiga, have to forget about those symbols */
  3231. +         if ((nl.n_type & ~N_EXT) == N_ABS)
  3232. +           continue;
  3233. + 
  3234. +         add_to_symbol_hunk(this_hunk, sp->name, nl.n_value);
  3235. + skip2:    ;
  3236. +       }
  3237. +       }
  3238. + }
  3239. + 
  3240. + void
  3241. + relocate_set_vectors (vectors, relvectors, num_entries)
  3242. +     unsigned long *vectors;
  3243. +     unsigned char *relvectors;
  3244. +     int num_entries;
  3245. + {
  3246. +   unsigned long i;
  3247. +   unsigned long offset = set_sect_start;
  3248. +   int hunk_num;
  3249. + 
  3250. +   while (num_entries-- > 0)
  3251. +     {
  3252. +       /* the number of entries for this symbol */
  3253. +       i = *vectors++; offset += 4; relvectors++;
  3254. +       while (num_entries --, i--)
  3255. +     {
  3256. +       /* relocation ok? */
  3257. +       if (*relvectors)
  3258. +         {
  3259. +           hunk_num = number_of_code_hunk;
  3260. +           if (*vectors >= text_size)
  3261. +             {
  3262. +           if (*vectors >= text_size + data_size)
  3263. +             {
  3264. +               hunk_num = number_of_bss_hunk;
  3265. +               if (databss_together)
  3266. +                 *vectors -= text_size;
  3267. +               else
  3268. +                 *vectors -= text_size + data_size;
  3269. +             }
  3270. +           else
  3271. +             {
  3272. +               hunk_num = number_of_data_hunk;
  3273. +               *vectors -= text_size;
  3274. +             }
  3275. +             }
  3276. +           add_to_reloc_hunk (hunk_num, offset);
  3277. +         }
  3278. +       ++vectors;
  3279. +       offset += 4;
  3280. +       ++relvectors;
  3281. +     }
  3282. +       /* check.. HAS to be zero */
  3283. +       if (*vectors)
  3284. +     fatal ("set-vector corrupt, num_entries = %d", num_entries);
  3285. +       vectors++; offset += 4; relvectors++; --num_entries;
  3286. +     }
  3287. + }
  3288. + #endif
  3289. + 
  3290. diff -2rcN binutils-1.8.x/objdump.c binutils-1.8.x-amiga/objdump.c
  3291. *** binutils-1.8.x/objdump.c    Sat Dec 30 00:16:07 1989
  3292. --- binutils-1.8.x-amiga/objdump.c    Wed Sep 22 12:45:33 1993
  3293. ***************
  3294. *** 25,30 ****
  3295.   #include "getopt.h"
  3296.   
  3297.   #ifndef COFF_ENCAPSULATE
  3298. ! #include <a.out.h>
  3299.   /* Tell a.out.gnu.h not to try to redefine some things.  */
  3300.   #define __STRUCT_EXEC_OVERRIDE__
  3301. --- 25,34 ----
  3302.   #include "getopt.h"
  3303.   
  3304. + #ifdef MCH_AMIGA
  3305. + #define getpagesize() 256
  3306. + #endif
  3307. + 
  3308.   #ifndef COFF_ENCAPSULATE
  3309. ! #include <sun/a.out.h>
  3310.   /* Tell a.out.gnu.h not to try to redefine some things.  */
  3311.   #define __STRUCT_EXEC_OVERRIDE__
  3312. diff -2rcN binutils-1.8.x/ranlib.c binutils-1.8.x-amiga/ranlib.c
  3313. *** binutils-1.8.x/ranlib.c    Thu Mar  1 00:18:42 1990
  3314. --- binutils-1.8.x-amiga/ranlib.c    Sat Jul 30 17:15:25 1994
  3315. ***************
  3316. *** 55,59 ****
  3317.   
  3318.   char *prog = AR_PROG;
  3319. ! char *prog_pref = "/usr/local/gnubin/ar";
  3320.   
  3321.   int
  3322. --- 55,59 ----
  3323.   
  3324.   char *prog = AR_PROG;
  3325. ! char *prog_pref = "/gnu/bin/ar";
  3326.   
  3327.   int
  3328. diff -2rcN binutils-1.8.x/strip.c binutils-1.8.x-amiga/strip.c
  3329. *** binutils-1.8.x/strip.c    Mon Jun 11 21:40:01 1990
  3330. --- binutils-1.8.x-amiga/strip.c    Wed Sep 22 12:45:43 1993
  3331. ***************
  3332. *** 72,76 ****
  3333.   /* If BSD, we can use `ftruncate'.  */
  3334.   
  3335. ! #ifndef USG
  3336.   #define HAVE_FTRUNCATE
  3337.   #endif
  3338. --- 72,76 ----
  3339.   /* If BSD, we can use `ftruncate'.  */
  3340.   
  3341. ! #if !defined(USG) && !defined(MCH_AMIGA)
  3342.   #define HAVE_FTRUNCATE
  3343.   #endif
  3344. ***************
  3345. *** 288,293 ****
  3346. --- 288,295 ----
  3347.   
  3348.     /* Handle any signal that came in while they were deferred.  */
  3349. + #ifndef MCH_AMIGA
  3350.     if (delayed_signal)
  3351.       kill (getpid (), delayed_signal);
  3352. + #endif
  3353.   }
  3354.   
  3355. ***************
  3356. *** 929,932 ****
  3357. --- 931,935 ----
  3358.   
  3359.   #ifdef USG
  3360. + #ifndef MCH_AMIGA
  3361.   
  3362.   rename (from, to)
  3363. ***************
  3364. *** 941,944 ****
  3365. --- 944,948 ----
  3366.   }
  3367.   
  3368. + #endif
  3369.   #endif
  3370.   
  3371.